From e4af31931e3cd6bc8248850b1ff613c3c0bc7854 Mon Sep 17 00:00:00 2001 From: kahirokunn Date: Thu, 9 May 2024 17:39:17 +0900 Subject: [PATCH] feat: initialize @kubekit/prepare project for generating Kubernetes OpenAPI specs based on ServiceAccount permissions --- .gitignore | 1 + packages/kubekit-prepare/.gitignore | 1 + packages/kubekit-prepare/README.md | 38 + .../kubekit-prepare/gen-config/rbac-v1.ts | 9 + packages/kubekit-prepare/gen-config/v1.ts | 9 + packages/kubekit-prepare/package.json | 47 + packages/kubekit-prepare/src/bin/cli.ts | 191 + packages/kubekit-prepare/src/config.ts | 6 + packages/kubekit-prepare/src/getRules.ts | 209 + .../kubekit-prepare/src/k8s-client/rbac-v1.ts | 2740 +++ packages/kubekit-prepare/src/k8s-client/v1.ts | 14340 ++++++++++++++++ packages/kubekit-prepare/src/lib.ts | 41 + .../src/patchOpenApi/applyPatch.ts | 66 + .../kubekit-prepare/src/patchOpenApi/gvk.ts | 44 + .../kubekit-prepare/src/patchOpenApi/index.ts | 10 + .../kubekit-prepare/src/patchOpenApi/op.ts | 195 + packages/kubekit-prepare/tests/test.yaml | 164 + .../kubekit-prepare/tests/test1.config.ts | 10 + packages/kubekit-prepare/tsconfig.json | 74 + packages/kubekit-prepare/yarn.lock | 1198 ++ 20 files changed, 19393 insertions(+) create mode 100644 packages/kubekit-prepare/.gitignore create mode 100644 packages/kubekit-prepare/README.md create mode 100644 packages/kubekit-prepare/gen-config/rbac-v1.ts create mode 100644 packages/kubekit-prepare/gen-config/v1.ts create mode 100644 packages/kubekit-prepare/package.json create mode 100755 packages/kubekit-prepare/src/bin/cli.ts create mode 100644 packages/kubekit-prepare/src/config.ts create mode 100644 packages/kubekit-prepare/src/getRules.ts create mode 100644 packages/kubekit-prepare/src/k8s-client/rbac-v1.ts create mode 100644 packages/kubekit-prepare/src/k8s-client/v1.ts create mode 100644 packages/kubekit-prepare/src/lib.ts create mode 100644 packages/kubekit-prepare/src/patchOpenApi/applyPatch.ts create mode 100644 packages/kubekit-prepare/src/patchOpenApi/gvk.ts create mode 100644 packages/kubekit-prepare/src/patchOpenApi/index.ts create mode 100644 packages/kubekit-prepare/src/patchOpenApi/op.ts create mode 100644 packages/kubekit-prepare/tests/test.yaml create mode 100644 packages/kubekit-prepare/tests/test1.config.ts create mode 100644 packages/kubekit-prepare/tsconfig.json create mode 100644 packages/kubekit-prepare/yarn.lock diff --git a/.gitignore b/.gitignore index 952ee709..2ee8b7be 100644 --- a/.gitignore +++ b/.gitignore @@ -37,3 +37,4 @@ eks-blueprints-add-ons examples/generate-vercel-client/swagger.json eks-blueprints-add-ons openapi +packages/kubekit-prepare/lib diff --git a/packages/kubekit-prepare/.gitignore b/packages/kubekit-prepare/.gitignore new file mode 100644 index 00000000..a9a5aecf --- /dev/null +++ b/packages/kubekit-prepare/.gitignore @@ -0,0 +1 @@ +tmp diff --git a/packages/kubekit-prepare/README.md b/packages/kubekit-prepare/README.md new file mode 100644 index 00000000..06f9cfc0 --- /dev/null +++ b/packages/kubekit-prepare/README.md @@ -0,0 +1,38 @@ +# Introduction + +The `@kubekit/prepare` project is a tool that generates a JSON file of OpenAPI specifications that describe operations that can be executed based on the permissions of Kubernetes ServiceAccount. This tool is particularly useful for application developers who use Kubernetes API. The generated `openapi.json` file is used as a schema file to generate client code in the `@kubekit/codegen` project. + +## Key Features + +- **Accurate Permission Checks**: Generates OpenAPI specifications that only include API operations that can be executed based on the permissions of the ServiceAccount. +- **Scalability**: Currently, only `ServiceAccount` is supported, but support for `User` and `Group` is also planned in the future. +- **Strict Type Definitions**: Provides more strict type definitions than the standard Swagger definitions of Kubernetes, promoting safer API usage. + +## Configuration + +To use the project, you need to configure the `config.ts` file. The following example shows how to configure a [ServiceAccount](file:///Users/kahiro/Documents/appthrust/kubekit-ts/packages/kubekit-prepare/README.md#3%2C22-3%2C22). + +```typescript:config.ts +import { ConfigFile } from "./config" + +const config: ConfigFile = { + kind: 'ServiceAccount', + name: 'replicaset-controller', + namespace: 'kube-system', + outputFile: './replicaset-controller.openapi.json', +} + +export default config +``` + +## Execution Method + +After creating the configuration file, execute the following command to generate `replicaset-controller.openapi.json`. + +```bash +npx @kubekit/prepare config.ts +``` + +## Future Prospects + +This project is currently under development and plans to add support for `User` and `Group`, as well as further feature enhancements. This is aimed at enabling more users to effectively utilize Kubernetes API. diff --git a/packages/kubekit-prepare/gen-config/rbac-v1.ts b/packages/kubekit-prepare/gen-config/rbac-v1.ts new file mode 100644 index 00000000..c0c865ca --- /dev/null +++ b/packages/kubekit-prepare/gen-config/rbac-v1.ts @@ -0,0 +1,9 @@ +import type { ConfigFile } from '@kubekit/codegen' + +const config: ConfigFile = { + schemaFile: '../openapi/apis/rbac.authorization.k8s.io/v1/swagger.json', + apiFile: '@kubekit/client', + outputFile: '../src/k8s-client/rbac-v1.ts', +} + +export default config diff --git a/packages/kubekit-prepare/gen-config/v1.ts b/packages/kubekit-prepare/gen-config/v1.ts new file mode 100644 index 00000000..a3a06190 --- /dev/null +++ b/packages/kubekit-prepare/gen-config/v1.ts @@ -0,0 +1,9 @@ +import type { ConfigFile } from '@kubekit/codegen' + +const config: ConfigFile = { + schemaFile: '../openapi/api/v1/swagger.json', + apiFile: '@kubekit/client', + outputFile: '../src/k8s-client/v1.ts', +} + +export default config diff --git a/packages/kubekit-prepare/package.json b/packages/kubekit-prepare/package.json new file mode 100644 index 00000000..bebc4704 --- /dev/null +++ b/packages/kubekit-prepare/package.json @@ -0,0 +1,47 @@ +{ + "name": "@kubekit/prepare", + "version": "0.0.1", + "main": "lib/index.js", + "author": "kahirokunn", + "license": "MIT", + "repository": { + "type": "git", + "url": "git+https://github.com/appthrust/kubekit-ts.git" + }, + "bugs": { + "url": "https://github.com/appthrust/kubekit-ts/issues" + }, + "homepage": "https://github.com/appthrust/kubekit-ts", + "bin": "lib/bin/cli.js", + "scripts": { + "build": "tsc", + "prepare": "tsc && chmod +x ./lib/bin/cli.js", + "sync": "npx @kubekit/sync ./", + "gen": "npx @kubekit/codegen gen-config/v1.ts && npx @kubekit/codegen gen-config/rbac-v1.ts", + "cli": "lib/bin/cli.js", + "test": "yarn build; chmod +x lib/bin/cli.js; yarn cli tests/test1.config.ts" + }, + "files": [ + "lib", + "src" + ], + "husky": { + "hooks": { + "pre-commit": "pretty-quick --staged" + } + }, + "devDependencies": { + "@kubekit/codegen": "^0.0.19", + "@kubekit/sync": "^0.0.21", + "@types/lodash.merge": "^4.6.9", + "@types/node": "^20.11.30", + "esbuild": "^0.21.1", + "esbuild-runner": "^2.2.2", + "openapi-types": "^12.1.3", + "typescript": "5.4.5" + }, + "dependencies": { + "@kubekit/client": "0.0.23", + "lodash.merge": "^4.6.2" + } +} diff --git a/packages/kubekit-prepare/src/bin/cli.ts b/packages/kubekit-prepare/src/bin/cli.ts new file mode 100755 index 00000000..7eb0e25c --- /dev/null +++ b/packages/kubekit-prepare/src/bin/cli.ts @@ -0,0 +1,191 @@ +#!/usr/bin/env node + +import program from 'commander' +import * as path from 'path' +import * as fs from 'fs/promises' +import { patchFunctions } from '../patchOpenApi' +import merge from 'lodash.merge' +import { OpenAPIV3 } from 'openapi-types' +import { type ResourceRules, inspectRules } from '../getRules' +import { assertNotNull, mapK8sVerbToHttpMethod } from '../lib' +import { apiClient } from '@kubekit/client' +import { ConfigFile } from '../config' +import { writeFile } from 'fs' + +let ts = false +try { + if (require.resolve('esbuild') && require.resolve('esbuild-runner')) { + require('esbuild-runner/register') + } + ts = true +} catch {} + +// tslint:disable-next-line +const meta = require('../../package.json') + +program.version(meta.version).usage('').parse(process.argv) + +const configFilePath = program.args[0] + +if ( + program.args.length === 0 || + !/\.(c?(jsx?|tsx?)|jsonc?)?$/.test(configFilePath) +) { + program.help() +} else { + if (/\.tsx?$/.test(configFilePath) && !ts) { + console.error( + 'Encountered a TypeScript configfile, but neither esbuild-runner nor ts-node are installed.' + ) + process.exit(1) + } + run(path.resolve(process.cwd(), configFilePath)) +} +async function run(configFilePath: string) { + process.chdir(path.dirname(configFilePath)) + + const unparsedConfig = require(configFilePath) + const config: ConfigFile = unparsedConfig.default ?? unparsedConfig + if (config.kind === 'Group' || config.kind === 'User') { + console.error('Group and User are not yet supported. Please open an issue.') + process.exit(1) + } + try { + console.log(`Generating ${config.outputFile}`) + await generateOpenApi(config) + console.log(`Done`) + } catch (err) { + console.error(err) + process.exit(1) + } +} + +async function generateOpenApi(config: ConfigFile) { + const [ + { + resourceRules, + // TODO: Implement nonResourceRules as well + nonResourceRules: _, + }, + rootOpenApiText, + ] = await Promise.all([ + inspectRules(config.kind, config.name, config.namespace), + apiClient({ path: '/openapi/v3' }), + ]) + + const source: OpenAPIV3.Document<{}> = JSON.parse(rootOpenApiText) + + const cwd = process.cwd() + + const sourcePaths = Object.keys(source.paths) + const docs: OpenAPIV3.Document<{}>[] = [] + + const addDoc = async (path: string, rule: ResourceRules[string]) => { + const sourceDoc = await apiClient>({ + path: `/openapi/v3/${path}`, + }) + const paths = Object.keys(sourceDoc.paths) + const resultDoc: OpenAPIV3.Document<{}> = { + ...sourceDoc, + paths: {}, + } + + for (const [resourceName, { verbs, namespaces }] of Object.entries(rule)) { + // "/apis/networking.k8s.io/v1/namespaces/{namespace}/ingresses/{name}" + // "/apis/networking.k8s.io/v1/ingresses" + // "/apis/networking.k8s.io/v1/watch/ingresses" + + const namespacedPaths = [ + // operation id: read | replace | delete | patch + // verb: "get" | "list" | "create" | "update" | "patch" | "delete" + `/${path}/namespaces/{namespace}/${resourceName}/{name}`, + // operation id: list | create | deletecollection + // verb: "deletecollection" | "proxy" | "watch" + `/${path}/namespaces/{namespace}/${resourceName}`, + // operation id: connect + // "proxy" + `/${path}/namespaces/{namespace}/${resourceName}/{name}/proxy`, + `/${path}/namespaces/{namespace}/${resourceName}/{name}/proxy/{path}`, + // /watch/はdeprecatedなので、無視します + ] + const clusterPath = `/${path}/${resourceName}` + + function isMatchedPath(fullPath: string) { + if (namespaces[0] === '*') { + return fullPath === clusterPath || namespacedPaths.includes(fullPath) + } + + return namespacedPaths.includes(fullPath) + } + paths + .filter((path) => isMatchedPath(path)) + .forEach((path) => { + // "get" | "list" | "watch" | "create" | "update" | "patch" | "delete" | "*" + // "operationId": "replaceEventsV1NamespacedEvent", + if (verbs[0] === '*') { + resultDoc.paths[path] = sourceDoc.paths[path] + } else { + const httpMethods = verbs.map((verb) => + mapK8sVerbToHttpMethod(verb) + ) + httpMethods.forEach((httpMethod) => { + if (sourceDoc.paths[path]?.[httpMethod]) { + if (!resultDoc.paths[path]) { + resultDoc.paths[path] = {} + } + const pathsObject = resultDoc.paths[path] + assertNotNull(pathsObject) + pathsObject[httpMethod] = sourceDoc.paths[path]?.[httpMethod] + } + }) + } + }) + } + docs.push(resultDoc) + } + + const tasks: Promise[] = [] + + if (resourceRules['']) { + const rule = resourceRules[''] + if (!sourcePaths.find((path) => path === 'api/v1')) { + throw Error('The coreV1 API was not found. This is an unexpected state.') + } + + tasks.push(addDoc('api/v1', rule)) + delete resourceRules[''] + } + + for (const [apiGroup, rule] of Object.entries(resourceRules)) { + const matchedApiGroups = sourcePaths.filter((path) => + path.startsWith(`apis/${apiGroup}/`) + ) + if (matchedApiGroups.length === 0) { + throw Error( + `The API group '${apiGroup}' is not installed on the k8s cluster. Have you forgotten to install the CRD?` + ) + } + matchedApiGroups.forEach((sourcePath) => + tasks.push(addDoc(sourcePath, rule)) + ) + } + + await Promise.all(tasks) + + let mergedSwaggerFile = merge({}, ...docs) + + for (const patchFunction of patchFunctions) { + mergedSwaggerFile = patchFunction(mergedSwaggerFile) + } + + const swaggerFilePath = path.join(config.outputFile || cwd, 'swagger.json') + + try { + fs.writeFile( + path.resolve(process.cwd(), config.outputFile), + JSON.stringify(mergedSwaggerFile, undefined, 2) + ) + } catch (e) { + console.error(`Failed to write file: ${swaggerFilePath}`, e) + } +} diff --git a/packages/kubekit-prepare/src/config.ts b/packages/kubekit-prepare/src/config.ts new file mode 100644 index 00000000..283a9e84 --- /dev/null +++ b/packages/kubekit-prepare/src/config.ts @@ -0,0 +1,6 @@ +export type ConfigFile = { + kind: 'ServiceAccount' | 'User' | 'Group' + name: string + namespace: string + outputFile: string +} diff --git a/packages/kubekit-prepare/src/getRules.ts b/packages/kubekit-prepare/src/getRules.ts new file mode 100644 index 00000000..2cb458f6 --- /dev/null +++ b/packages/kubekit-prepare/src/getRules.ts @@ -0,0 +1,209 @@ +import { + IoK8SApiRbacV1ClusterRole, + IoK8SApiRbacV1PolicyRule, + IoK8SApiRbacV1Role, + listRbacAuthorizationV1ClusterRoleBinding, + listRbacAuthorizationV1RoleBindingForAllNamespaces, + readRbacAuthorizationV1ClusterRole, + readRbacAuthorizationV1NamespacedRole, +} from './k8s-client/rbac-v1' + +type Url = string + +export async function inspectRules( + kind: string, + name: string, + namespace: string +) { + const resourceRules = {} as ResourceRules + const nonResourceRules = {} as NonResourceRules + + const roles = await getRoles(kind, name, namespace) + mutateDict(roles, resourceRules, nonResourceRules) + + const clusterRoles = await getClusterRoles(kind, name, namespace) + mutateDict(clusterRoles, resourceRules, nonResourceRules) + + return { + resourceRules, + nonResourceRules, + } +} + +async function getRoles(kind: string, name: string, namespace: string) { + const roleBindings = await listRbacAuthorizationV1RoleBindingForAllNamespaces( + {} + ) + + const subjectRoles = roleBindings.items + .filter( + (b) => + b.roleRef.apiGroup === 'rbac.authorization.k8s.io' && + b.roleRef.kind === 'Role' && + b.subjects + ) + .map((b) => ({ + ...b, + roleRef: { + ...b.roleRef, + namespace: b.metadata.namespace, + }, + subjects: b.subjects?.map((s) => ({ + ...s, + namespace: s.namespace || b.metadata.namespace, + })), + })) + .filter( + (b) => + b.subjects?.findIndex( + (subject) => + subject.kind === kind && + subject.name === name && + subject.namespace === namespace + ) !== -1 + ) + .map((b) => b.roleRef) + + return await Promise.all( + subjectRoles.map(({ name, namespace }) => + readRbacAuthorizationV1NamespacedRole({ + name, + namespace, + }) + ) + ) +} + +async function getClusterRoles(kind: string, name: string, namespace: string) { + const clusterRoleBindings = await listRbacAuthorizationV1ClusterRoleBinding( + {} + ) + + const subjectClusterRoles = clusterRoleBindings.items + .filter( + (b) => + b.roleRef.apiGroup === 'rbac.authorization.k8s.io' && + b.roleRef.kind === 'ClusterRole' && + b.subjects + ) + .map((b) => ({ + ...b, + subjects: b.subjects?.map((s) => ({ + ...s, + namespace: s.namespace || b.metadata.namespace, + })), + })) + .filter( + (b) => + b.subjects?.findIndex( + (subject) => + subject.kind === kind && + subject.name === name && + subject.namespace === namespace + ) !== -1 + ) + .map((b) => b.roleRef) + .filter((v) => v) + + return await Promise.all( + subjectClusterRoles.map((subjectClusterRole) => + readRbacAuthorizationV1ClusterRole({ + name: subjectClusterRole!.name, + }) + ) + ) +} + +export type ResourceVerb = + | 'get' + | 'list' + | 'watch' + | 'create' + | 'update' + | 'patch' + | 'delete' + | 'deletecollection' + | 'proxy' + | '*' +// TODO: more verbs... +type NonResourceVerb = 'get' | 'post' | '*' +type ApiGroup = string +type ResourceName = string +type Resource = { + verbs: ResourceVerb[] + namespaces: string[] +} +export type ResourceRules = Record> +type NonResourceRules = Record< + Url, + { + verbs: NonResourceVerb[] + } +> + +// TODO: more then better name... +function mutateDict( + roles: (IoK8SApiRbacV1Role | IoK8SApiRbacV1ClusterRole)[], + resourceRules: ResourceRules, + nonResourceRules: NonResourceRules +) { + const allRules = roles + .filter((role) => role) + .map((role) => { + const rules = role.rules as IoK8SApiRbacV1PolicyRule[] + return rules.map((rule) => ({ + ...rule, + namespace: role.metadata!.namespace || '*', + })) + }) + .flat() + + allRules.forEach((rule) => { + if (!rule) return + rule.apiGroups?.forEach((apiGroup) => { + if (!resourceRules[apiGroup]) { + resourceRules[apiGroup] = {} + } + rule.resources?.forEach((resourceName) => { + if (!resourceRules[apiGroup][resourceName]) { + resourceRules[apiGroup][resourceName] = { + verbs: [], + namespaces: [], + } + } + const resource = resourceRules[apiGroup][resourceName] + if (!resource.namespaces.find((n) => n === rule.namespace)) { + if (rule.namespace === '*') { + resource.namespaces = ['*'] + } else { + resource.namespaces.push(rule.namespace) + } + } + rule.verbs.forEach((verb) => { + if (resource.verbs.find((v) => v === verb)) return + if (verb === '*') { + resource.verbs = ['*'] + } else { + resource.verbs.push(verb as ResourceVerb) + } + }) + }) + }) + rule.nonResourceURLs?.forEach((url) => { + if (!nonResourceRules[url]) { + nonResourceRules[url] = { + verbs: [], + } + } + rule.verbs.forEach((verb) => { + if (nonResourceRules[url].verbs.find((v) => v === verb)) return + nonResourceRules[url].verbs.push(verb as NonResourceVerb) + }) + }) + }) + + return { + resourceRules, + nonResourceRules, + } +} diff --git a/packages/kubekit-prepare/src/k8s-client/rbac-v1.ts b/packages/kubekit-prepare/src/k8s-client/rbac-v1.ts new file mode 100644 index 00000000..e768eafa --- /dev/null +++ b/packages/kubekit-prepare/src/k8s-client/rbac-v1.ts @@ -0,0 +1,2740 @@ +import { + apiClient, + type Options, + type WatchExtraOptions, +} from '@kubekit/client' +type Id = { + [K in keyof T]: T[K] +} & {} +type NoWatch = Omit & { + watch?: false +} +type RequiredAndDefined = { + [P in keyof T]-?: Exclude +} +type PartialRequired = Id< + RequiredAndDefined> & Omit +> +type MinimumRequiredGet = Id< + T extends { + metadata?: any + apiVersion?: any + kind?: any + } + ? Omit< + PartialRequired, + 'metadata' + > & { + metadata: PartialRequired< + RequiredAndDefined['metadata'], + 'name' | 'namespace' | 'creationTimestamp' | 'resourceVersion' + > + } + : T +> +type MinimumRequiredList = Id< + T extends { + items: { + metadata?: any + apiVersion?: any + kind?: any + }[] + } + ? Omit & { + items: MinimumRequiredGet[] + } + : T +> +export const getRbacAuthorizationV1ApiResources = (options?: Options) => { + return apiClient< + MinimumRequiredGet + >({ path: `/apis/rbac.authorization.k8s.io/v1/` }, options) +} +export function listRbacAuthorizationV1ClusterRoleBinding( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listRbacAuthorizationV1ClusterRoleBinding( + args: ListRbacAuthorizationV1ClusterRoleBindingApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listRbacAuthorizationV1ClusterRoleBinding( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterrolebindings`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createRbacAuthorizationV1ClusterRoleBinding = ( + args: CreateRbacAuthorizationV1ClusterRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterrolebindings`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteRbacAuthorizationV1CollectionClusterRoleBinding = ( + args: DeleteRbacAuthorizationV1CollectionClusterRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterrolebindings`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readRbacAuthorizationV1ClusterRoleBinding = ( + args: ReadRbacAuthorizationV1ClusterRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceRbacAuthorizationV1ClusterRoleBinding = ( + args: ReplaceRbacAuthorizationV1ClusterRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteRbacAuthorizationV1ClusterRoleBinding = ( + args: DeleteRbacAuthorizationV1ClusterRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchRbacAuthorizationV1ClusterRoleBinding = ( + args: PatchRbacAuthorizationV1ClusterRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listRbacAuthorizationV1ClusterRole( + args: NoWatch, + options?: Options +): Promise> +export function listRbacAuthorizationV1ClusterRole( + args: ListRbacAuthorizationV1ClusterRoleApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listRbacAuthorizationV1ClusterRole( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterroles`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createRbacAuthorizationV1ClusterRole = ( + args: CreateRbacAuthorizationV1ClusterRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterroles`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteRbacAuthorizationV1CollectionClusterRole = ( + args: DeleteRbacAuthorizationV1CollectionClusterRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterroles`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readRbacAuthorizationV1ClusterRole = ( + args: ReadRbacAuthorizationV1ClusterRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterroles/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceRbacAuthorizationV1ClusterRole = ( + args: ReplaceRbacAuthorizationV1ClusterRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterroles/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteRbacAuthorizationV1ClusterRole = ( + args: DeleteRbacAuthorizationV1ClusterRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterroles/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchRbacAuthorizationV1ClusterRole = ( + args: PatchRbacAuthorizationV1ClusterRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/clusterroles/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listRbacAuthorizationV1NamespacedRoleBinding( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listRbacAuthorizationV1NamespacedRoleBinding( + args: ListRbacAuthorizationV1NamespacedRoleBindingApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listRbacAuthorizationV1NamespacedRoleBinding( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/rolebindings`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createRbacAuthorizationV1NamespacedRoleBinding = ( + args: CreateRbacAuthorizationV1NamespacedRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/rolebindings`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteRbacAuthorizationV1CollectionNamespacedRoleBinding = ( + args: DeleteRbacAuthorizationV1CollectionNamespacedRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/rolebindings`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readRbacAuthorizationV1NamespacedRoleBinding = ( + args: ReadRbacAuthorizationV1NamespacedRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/rolebindings/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceRbacAuthorizationV1NamespacedRoleBinding = ( + args: ReplaceRbacAuthorizationV1NamespacedRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/rolebindings/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteRbacAuthorizationV1NamespacedRoleBinding = ( + args: DeleteRbacAuthorizationV1NamespacedRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/rolebindings/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchRbacAuthorizationV1NamespacedRoleBinding = ( + args: PatchRbacAuthorizationV1NamespacedRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/rolebindings/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listRbacAuthorizationV1NamespacedRole( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listRbacAuthorizationV1NamespacedRole( + args: ListRbacAuthorizationV1NamespacedRoleApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listRbacAuthorizationV1NamespacedRole( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/roles`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createRbacAuthorizationV1NamespacedRole = ( + args: CreateRbacAuthorizationV1NamespacedRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/roles`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteRbacAuthorizationV1CollectionNamespacedRole = ( + args: DeleteRbacAuthorizationV1CollectionNamespacedRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/roles`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readRbacAuthorizationV1NamespacedRole = ( + args: ReadRbacAuthorizationV1NamespacedRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/roles/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceRbacAuthorizationV1NamespacedRole = ( + args: ReplaceRbacAuthorizationV1NamespacedRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/roles/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteRbacAuthorizationV1NamespacedRole = ( + args: DeleteRbacAuthorizationV1NamespacedRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/roles/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchRbacAuthorizationV1NamespacedRole = ( + args: PatchRbacAuthorizationV1NamespacedRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/namespaces/${args['namespace']}/roles/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listRbacAuthorizationV1RoleBindingForAllNamespaces( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listRbacAuthorizationV1RoleBindingForAllNamespaces( + args: ListRbacAuthorizationV1RoleBindingForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listRbacAuthorizationV1RoleBindingForAllNamespaces( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/rolebindings`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listRbacAuthorizationV1RoleForAllNamespaces( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listRbacAuthorizationV1RoleForAllNamespaces( + args: ListRbacAuthorizationV1RoleForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listRbacAuthorizationV1RoleForAllNamespaces( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/roles`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchRbacAuthorizationV1ClusterRoleBindingList = ( + args: WatchRbacAuthorizationV1ClusterRoleBindingListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchRbacAuthorizationV1ClusterRoleBinding = ( + args: WatchRbacAuthorizationV1ClusterRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchRbacAuthorizationV1ClusterRoleList = ( + args: WatchRbacAuthorizationV1ClusterRoleListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/watch/clusterroles`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchRbacAuthorizationV1ClusterRole = ( + args: WatchRbacAuthorizationV1ClusterRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/watch/clusterroles/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchRbacAuthorizationV1NamespacedRoleBindingList = ( + args: WatchRbacAuthorizationV1NamespacedRoleBindingListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/watch/namespaces/${args['namespace']}/rolebindings`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchRbacAuthorizationV1NamespacedRoleBinding = ( + args: WatchRbacAuthorizationV1NamespacedRoleBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/watch/namespaces/${args['namespace']}/rolebindings/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchRbacAuthorizationV1NamespacedRoleList = ( + args: WatchRbacAuthorizationV1NamespacedRoleListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/watch/namespaces/${args['namespace']}/roles`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchRbacAuthorizationV1NamespacedRole = ( + args: WatchRbacAuthorizationV1NamespacedRoleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/watch/namespaces/${args['namespace']}/roles/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchRbacAuthorizationV1RoleBindingListForAllNamespaces = ( + args: WatchRbacAuthorizationV1RoleBindingListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/watch/rolebindings`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchRbacAuthorizationV1RoleListForAllNamespaces = ( + args: WatchRbacAuthorizationV1RoleListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/apis/rbac.authorization.k8s.io/v1/watch/roles`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export type GetRbacAuthorizationV1ApiResourcesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1ApiResourceList +export type GetRbacAuthorizationV1ApiResourcesApiArg = void +export type ListRbacAuthorizationV1ClusterRoleBindingApiResponse = + /** status 200 OK */ IoK8SApiRbacV1ClusterRoleBindingList +export type ListRbacAuthorizationV1ClusterRoleBindingApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateRbacAuthorizationV1ClusterRoleBindingApiResponse = + /** status 200 OK */ + | IoK8SApiRbacV1ClusterRoleBinding + | /** status 201 Created */ IoK8SApiRbacV1ClusterRoleBinding + | /** status 202 Accepted */ IoK8SApiRbacV1ClusterRoleBinding +export type CreateRbacAuthorizationV1ClusterRoleBindingApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiRbacV1ClusterRoleBinding +} +export type DeleteRbacAuthorizationV1CollectionClusterRoleBindingApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteRbacAuthorizationV1CollectionClusterRoleBindingApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadRbacAuthorizationV1ClusterRoleBindingApiResponse = + /** status 200 OK */ IoK8SApiRbacV1ClusterRoleBinding +export type ReadRbacAuthorizationV1ClusterRoleBindingApiArg = { + /** name of the ClusterRoleBinding */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceRbacAuthorizationV1ClusterRoleBindingApiResponse = + /** status 200 OK */ + | IoK8SApiRbacV1ClusterRoleBinding + | /** status 201 Created */ IoK8SApiRbacV1ClusterRoleBinding +export type ReplaceRbacAuthorizationV1ClusterRoleBindingApiArg = { + /** name of the ClusterRoleBinding */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiRbacV1ClusterRoleBinding +} +export type DeleteRbacAuthorizationV1ClusterRoleBindingApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteRbacAuthorizationV1ClusterRoleBindingApiArg = { + /** name of the ClusterRoleBinding */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchRbacAuthorizationV1ClusterRoleBindingApiResponse = + /** status 200 OK */ + | IoK8SApiRbacV1ClusterRoleBinding + | /** status 201 Created */ IoK8SApiRbacV1ClusterRoleBinding +export type PatchRbacAuthorizationV1ClusterRoleBindingApiArg = { + /** name of the ClusterRoleBinding */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiRbacV1ClusterRoleBinding & { + apiVersion: 'rbac.authorization.k8s.io' + kind: 'ClusterRoleBinding' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiRbacV1ClusterRoleBinding + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiRbacV1ClusterRoleBinding + } +) +export type ListRbacAuthorizationV1ClusterRoleApiResponse = + /** status 200 OK */ IoK8SApiRbacV1ClusterRoleList +export type ListRbacAuthorizationV1ClusterRoleApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateRbacAuthorizationV1ClusterRoleApiResponse = + /** status 200 OK */ + | IoK8SApiRbacV1ClusterRole + | /** status 201 Created */ IoK8SApiRbacV1ClusterRole + | /** status 202 Accepted */ IoK8SApiRbacV1ClusterRole +export type CreateRbacAuthorizationV1ClusterRoleApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiRbacV1ClusterRole +} +export type DeleteRbacAuthorizationV1CollectionClusterRoleApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteRbacAuthorizationV1CollectionClusterRoleApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadRbacAuthorizationV1ClusterRoleApiResponse = + /** status 200 OK */ IoK8SApiRbacV1ClusterRole +export type ReadRbacAuthorizationV1ClusterRoleApiArg = { + /** name of the ClusterRole */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceRbacAuthorizationV1ClusterRoleApiResponse = + /** status 200 OK */ + | IoK8SApiRbacV1ClusterRole + | /** status 201 Created */ IoK8SApiRbacV1ClusterRole +export type ReplaceRbacAuthorizationV1ClusterRoleApiArg = { + /** name of the ClusterRole */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiRbacV1ClusterRole +} +export type DeleteRbacAuthorizationV1ClusterRoleApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteRbacAuthorizationV1ClusterRoleApiArg = { + /** name of the ClusterRole */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchRbacAuthorizationV1ClusterRoleApiResponse = + /** status 200 OK */ + | IoK8SApiRbacV1ClusterRole + | /** status 201 Created */ IoK8SApiRbacV1ClusterRole +export type PatchRbacAuthorizationV1ClusterRoleApiArg = { + /** name of the ClusterRole */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiRbacV1ClusterRole & { + apiVersion: 'rbac.authorization.k8s.io' + kind: 'ClusterRole' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiRbacV1ClusterRole + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiRbacV1ClusterRole + } +) +export type ListRbacAuthorizationV1NamespacedRoleBindingApiResponse = + /** status 200 OK */ IoK8SApiRbacV1RoleBindingList +export type ListRbacAuthorizationV1NamespacedRoleBindingApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateRbacAuthorizationV1NamespacedRoleBindingApiResponse = + /** status 200 OK */ + | IoK8SApiRbacV1RoleBinding + | /** status 201 Created */ IoK8SApiRbacV1RoleBinding + | /** status 202 Accepted */ IoK8SApiRbacV1RoleBinding +export type CreateRbacAuthorizationV1NamespacedRoleBindingApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiRbacV1RoleBinding +} +export type DeleteRbacAuthorizationV1CollectionNamespacedRoleBindingApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteRbacAuthorizationV1CollectionNamespacedRoleBindingApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadRbacAuthorizationV1NamespacedRoleBindingApiResponse = + /** status 200 OK */ IoK8SApiRbacV1RoleBinding +export type ReadRbacAuthorizationV1NamespacedRoleBindingApiArg = { + /** name of the RoleBinding */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceRbacAuthorizationV1NamespacedRoleBindingApiResponse = + /** status 200 OK */ + | IoK8SApiRbacV1RoleBinding + | /** status 201 Created */ IoK8SApiRbacV1RoleBinding +export type ReplaceRbacAuthorizationV1NamespacedRoleBindingApiArg = { + /** name of the RoleBinding */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiRbacV1RoleBinding +} +export type DeleteRbacAuthorizationV1NamespacedRoleBindingApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteRbacAuthorizationV1NamespacedRoleBindingApiArg = { + /** name of the RoleBinding */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchRbacAuthorizationV1NamespacedRoleBindingApiResponse = + /** status 200 OK */ + | IoK8SApiRbacV1RoleBinding + | /** status 201 Created */ IoK8SApiRbacV1RoleBinding +export type PatchRbacAuthorizationV1NamespacedRoleBindingApiArg = { + /** name of the RoleBinding */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiRbacV1RoleBinding & { + apiVersion: 'rbac.authorization.k8s.io/v1' + kind: 'RoleBinding' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiRbacV1RoleBinding + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiRbacV1RoleBinding + } +) +export type ListRbacAuthorizationV1NamespacedRoleApiResponse = + /** status 200 OK */ IoK8SApiRbacV1RoleList +export type ListRbacAuthorizationV1NamespacedRoleApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateRbacAuthorizationV1NamespacedRoleApiResponse = + /** status 200 OK */ + | IoK8SApiRbacV1Role + | /** status 201 Created */ IoK8SApiRbacV1Role + | /** status 202 Accepted */ IoK8SApiRbacV1Role +export type CreateRbacAuthorizationV1NamespacedRoleApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiRbacV1Role +} +export type DeleteRbacAuthorizationV1CollectionNamespacedRoleApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteRbacAuthorizationV1CollectionNamespacedRoleApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadRbacAuthorizationV1NamespacedRoleApiResponse = + /** status 200 OK */ IoK8SApiRbacV1Role +export type ReadRbacAuthorizationV1NamespacedRoleApiArg = { + /** name of the Role */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceRbacAuthorizationV1NamespacedRoleApiResponse = + /** status 200 OK */ + IoK8SApiRbacV1Role | /** status 201 Created */ IoK8SApiRbacV1Role +export type ReplaceRbacAuthorizationV1NamespacedRoleApiArg = { + /** name of the Role */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiRbacV1Role +} +export type DeleteRbacAuthorizationV1NamespacedRoleApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteRbacAuthorizationV1NamespacedRoleApiArg = { + /** name of the Role */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchRbacAuthorizationV1NamespacedRoleApiResponse = + /** status 200 OK */ + IoK8SApiRbacV1Role | /** status 201 Created */ IoK8SApiRbacV1Role +export type PatchRbacAuthorizationV1NamespacedRoleApiArg = { + /** name of the Role */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiRbacV1Role & { + apiVersion: 'rbac.authorization.k8s.io/v1' + kind: 'Role' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiRbacV1Role + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiRbacV1Role + } +) +export type ListRbacAuthorizationV1RoleBindingForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiRbacV1RoleBindingList +export type ListRbacAuthorizationV1RoleBindingForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListRbacAuthorizationV1RoleForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiRbacV1RoleList +export type ListRbacAuthorizationV1RoleForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchRbacAuthorizationV1ClusterRoleBindingListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchRbacAuthorizationV1ClusterRoleBindingListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchRbacAuthorizationV1ClusterRoleBindingApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchRbacAuthorizationV1ClusterRoleBindingApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the ClusterRoleBinding */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchRbacAuthorizationV1ClusterRoleListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchRbacAuthorizationV1ClusterRoleListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchRbacAuthorizationV1ClusterRoleApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchRbacAuthorizationV1ClusterRoleApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the ClusterRole */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchRbacAuthorizationV1NamespacedRoleBindingListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchRbacAuthorizationV1NamespacedRoleBindingListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchRbacAuthorizationV1NamespacedRoleBindingApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchRbacAuthorizationV1NamespacedRoleBindingApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the RoleBinding */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchRbacAuthorizationV1NamespacedRoleListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchRbacAuthorizationV1NamespacedRoleListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchRbacAuthorizationV1NamespacedRoleApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchRbacAuthorizationV1NamespacedRoleApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the Role */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchRbacAuthorizationV1RoleBindingListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchRbacAuthorizationV1RoleBindingListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchRbacAuthorizationV1RoleListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchRbacAuthorizationV1RoleListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type IoK8SApimachineryPkgApisMetaV1ApiResource = { + categories?: string[] | undefined + group?: string | undefined + kind: string + name: string + namespaced: boolean + shortNames?: string[] | undefined + singularName: string + storageVersionHash?: string | undefined + verbs: string[] + version?: string | undefined +} +export type IoK8SApimachineryPkgApisMetaV1ApiResourceList = { + apiVersion?: string | undefined + groupVersion: string + kind?: string | undefined + resources: IoK8SApimachineryPkgApisMetaV1ApiResource[] +} +export type IoK8SApimachineryPkgApisMetaV1Time = string +export type IoK8SApimachineryPkgApisMetaV1FieldsV1 = object +export type IoK8SApimachineryPkgApisMetaV1ManagedFieldsEntry = { + apiVersion?: string | undefined + fieldsType?: string | undefined + fieldsV1?: IoK8SApimachineryPkgApisMetaV1FieldsV1 | undefined + manager?: string | undefined + operation?: string | undefined + subresource?: string | undefined + time?: IoK8SApimachineryPkgApisMetaV1Time | undefined +} +export type IoK8SApimachineryPkgApisMetaV1OwnerReference = { + apiVersion: string + blockOwnerDeletion?: boolean | undefined + controller?: boolean | undefined + kind: string + name: string + uid: string +} +export type IoK8SApimachineryPkgApisMetaV1ObjectMeta = { + annotations?: + | { + [key: string]: string + } + | undefined + creationTimestamp?: IoK8SApimachineryPkgApisMetaV1Time | undefined + deletionGracePeriodSeconds?: number | undefined + deletionTimestamp?: IoK8SApimachineryPkgApisMetaV1Time | undefined + finalizers?: string[] | undefined + generateName?: string | undefined + generation?: number | undefined + labels?: + | { + [key: string]: string + } + | undefined + managedFields?: IoK8SApimachineryPkgApisMetaV1ManagedFieldsEntry[] | undefined + name?: string | undefined + namespace?: string | undefined + ownerReferences?: IoK8SApimachineryPkgApisMetaV1OwnerReference[] | undefined + resourceVersion?: string | undefined + selfLink?: string | undefined + uid?: string | undefined +} +export type IoK8SApiRbacV1RoleRef = { + apiGroup: string + kind: string + name: string +} +export type IoK8SApiRbacV1Subject = { + apiGroup?: string | undefined + kind: string + name: string + namespace?: string | undefined +} +export type IoK8SApiRbacV1ClusterRoleBinding = { + apiVersion?: 'k8s.api.rbac.io/v1' | undefined + kind?: 'ClusterRoleBinding' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + roleRef: IoK8SApiRbacV1RoleRef + subjects?: IoK8SApiRbacV1Subject[] | undefined +} +export type IoK8SApimachineryPkgApisMetaV1ListMeta = { + continue?: string | undefined + remainingItemCount?: number | undefined + resourceVersion?: string | undefined + selfLink?: string | undefined +} +export type IoK8SApiRbacV1ClusterRoleBindingList = { + apiVersion: 'v1' + items: IoK8SApiRbacV1ClusterRoleBinding[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApimachineryPkgApisMetaV1StatusCause = { + field?: string | undefined + message?: string | undefined + reason?: string | undefined +} +export type IoK8SApimachineryPkgApisMetaV1StatusDetails = { + causes?: IoK8SApimachineryPkgApisMetaV1StatusCause[] | undefined + group?: string | undefined + kind?: string | undefined + name?: string | undefined + retryAfterSeconds?: number | undefined + uid?: string | undefined +} +export type IoK8SApimachineryPkgApisMetaV1Status = { + apiVersion?: 'k8s.apimachinery.pkg.apis.meta.io/v1' | undefined + code?: number | undefined + details?: IoK8SApimachineryPkgApisMetaV1StatusDetails | undefined + kind?: 'Status' | undefined + message?: string | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ListMeta | undefined + reason?: string | undefined + status?: string | undefined +} +export type IoK8SApimachineryPkgApisMetaV1Preconditions = { + resourceVersion?: string | undefined + uid?: string | undefined +} +export type IoK8SApimachineryPkgApisMetaV1DeleteOptions = { + apiVersion?: string | undefined + dryRun?: string[] | undefined + gracePeriodSeconds?: number | undefined + kind?: string | undefined + orphanDependents?: boolean | undefined + preconditions?: IoK8SApimachineryPkgApisMetaV1Preconditions | undefined + propagationPolicy?: string | undefined +} +export type AddOperation = { + op: 'add' + path: string + value: string | number | boolean | any | object +} +export type RemoveOperation = { + op: 'remove' + path: string +} +export type ReplaceOperation = { + op: 'replace' + path: string + value: string | number | boolean | any | object +} +export type MoveOperation = { + op: 'move' + path: string + from: string +} +export type CopyOperation = { + op: 'copy' + path: string + from: string +} +export type TestOperation = { + op: 'test' + path: string + value: string | number | boolean | any | object +} +export type JsonPatchOperation = + | AddOperation + | RemoveOperation + | ReplaceOperation + | MoveOperation + | CopyOperation + | TestOperation +export type JsonPatchOperations = JsonPatchOperation[] +export type IoK8SApimachineryPkgApisMetaV1LabelSelectorRequirement = { + key: string + operator: string + values?: string[] | undefined +} +export type IoK8SApimachineryPkgApisMetaV1LabelSelector = { + matchExpressions?: + | IoK8SApimachineryPkgApisMetaV1LabelSelectorRequirement[] + | undefined + matchLabels?: + | { + [key: string]: string + } + | undefined +} +export type IoK8SApiRbacV1AggregationRule = { + clusterRoleSelectors?: + | IoK8SApimachineryPkgApisMetaV1LabelSelector[] + | undefined +} +export type IoK8SApiRbacV1PolicyRule = { + apiGroups?: string[] | undefined + nonResourceURLs?: string[] | undefined + resourceNames?: string[] | undefined + resources?: string[] | undefined + verbs: string[] +} +export type IoK8SApiRbacV1ClusterRole = { + aggregationRule?: IoK8SApiRbacV1AggregationRule | undefined + apiVersion?: 'k8s.api.rbac.io/v1' | undefined + kind?: 'ClusterRole' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + rules?: IoK8SApiRbacV1PolicyRule[] | undefined +} +export type IoK8SApiRbacV1ClusterRoleList = { + apiVersion: 'v1' + items: IoK8SApiRbacV1ClusterRole[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiRbacV1RoleBinding = { + apiVersion?: 'k8s.api.rbac.io/v1' | undefined + kind?: 'RoleBinding' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + roleRef: IoK8SApiRbacV1RoleRef + subjects?: IoK8SApiRbacV1Subject[] | undefined +} +export type IoK8SApiRbacV1RoleBindingList = { + apiVersion: 'v1' + items: IoK8SApiRbacV1RoleBinding[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiRbacV1Role = { + apiVersion?: 'k8s.api.rbac.io/v1' | undefined + kind?: 'Role' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + rules?: IoK8SApiRbacV1PolicyRule[] | undefined +} +export type IoK8SApiRbacV1RoleList = { + apiVersion: 'v1' + items: IoK8SApiRbacV1Role[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApimachineryPkgRuntimeRawExtension = object +export type IoK8SApimachineryPkgApisMetaV1WatchEvent = { + object: IoK8SApimachineryPkgRuntimeRawExtension + type: string +} diff --git a/packages/kubekit-prepare/src/k8s-client/v1.ts b/packages/kubekit-prepare/src/k8s-client/v1.ts new file mode 100644 index 00000000..2fc2ac83 --- /dev/null +++ b/packages/kubekit-prepare/src/k8s-client/v1.ts @@ -0,0 +1,14340 @@ +import { + apiClient, + type Options, + type WatchExtraOptions, +} from '@kubekit/client' +type Id = { + [K in keyof T]: T[K] +} & {} +type NoWatch = Omit & { + watch?: false +} +type RequiredAndDefined = { + [P in keyof T]-?: Exclude +} +type PartialRequired = Id< + RequiredAndDefined> & Omit +> +type MinimumRequiredGet = Id< + T extends { + metadata?: any + apiVersion?: any + kind?: any + } + ? Omit< + PartialRequired, + 'metadata' + > & { + metadata: PartialRequired< + RequiredAndDefined['metadata'], + 'name' | 'namespace' | 'creationTimestamp' | 'resourceVersion' + > + } + : T +> +type MinimumRequiredList = Id< + T extends { + items: { + metadata?: any + apiVersion?: any + kind?: any + }[] + } + ? Omit & { + items: MinimumRequiredGet[] + } + : T +> +export const getCoreV1ApiResources = (options?: Options) => { + return apiClient>( + { path: `/api/v1/` }, + options + ) +} +export function listCoreV1ComponentStatus( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1ComponentStatus( + args: ListCoreV1ComponentStatusApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions> +): Promise +export function listCoreV1ComponentStatus(args: any, options: any): any { + return apiClient>( + { + path: `/api/v1/componentstatuses`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const readCoreV1ComponentStatus = ( + args: ReadCoreV1ComponentStatusApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/componentstatuses/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export function listCoreV1ConfigMapForAllNamespaces( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1ConfigMapForAllNamespaces( + args: ListCoreV1ConfigMapForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1ConfigMapForAllNamespaces( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/configmaps`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listCoreV1EndpointsForAllNamespaces( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1EndpointsForAllNamespaces( + args: ListCoreV1EndpointsForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1EndpointsForAllNamespaces( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/endpoints`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listCoreV1EventForAllNamespaces( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1EventForAllNamespaces( + args: ListCoreV1EventForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1EventForAllNamespaces(args: any, options: any): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/events`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listCoreV1LimitRangeForAllNamespaces( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1LimitRangeForAllNamespaces( + args: ListCoreV1LimitRangeForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1LimitRangeForAllNamespaces( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/limitranges`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listCoreV1Namespace( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1Namespace( + args: ListCoreV1NamespaceApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions> +): Promise +export function listCoreV1Namespace(args: any, options: any): any { + return apiClient>( + { + path: `/api/v1/namespaces`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1Namespace = ( + args: CreateCoreV1NamespaceApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const createCoreV1NamespacedBinding = ( + args: CreateCoreV1NamespacedBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/bindings`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + pretty: args.pretty, + }, + }, + options + ) +} +export function listCoreV1NamespacedConfigMap( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1NamespacedConfigMap( + args: ListCoreV1NamespacedConfigMapApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1NamespacedConfigMap(args: any, options: any): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/namespaces/${args['namespace']}/configmaps`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedConfigMap = ( + args: CreateCoreV1NamespacedConfigMapApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/configmaps`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedConfigMap = ( + args: DeleteCoreV1CollectionNamespacedConfigMapApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/configmaps`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedConfigMap = ( + args: ReadCoreV1NamespacedConfigMapApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/configmaps/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedConfigMap = ( + args: ReplaceCoreV1NamespacedConfigMapApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/configmaps/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedConfigMap = ( + args: DeleteCoreV1NamespacedConfigMapApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/configmaps/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedConfigMap = ( + args: PatchCoreV1NamespacedConfigMapApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/configmaps/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1NamespacedEndpoints( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1NamespacedEndpoints( + args: ListCoreV1NamespacedEndpointsApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1NamespacedEndpoints(args: any, options: any): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/namespaces/${args['namespace']}/endpoints`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedEndpoints = ( + args: CreateCoreV1NamespacedEndpointsApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/endpoints`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedEndpoints = ( + args: DeleteCoreV1CollectionNamespacedEndpointsApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/endpoints`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedEndpoints = ( + args: ReadCoreV1NamespacedEndpointsApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/endpoints/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedEndpoints = ( + args: ReplaceCoreV1NamespacedEndpointsApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/endpoints/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedEndpoints = ( + args: DeleteCoreV1NamespacedEndpointsApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/endpoints/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedEndpoints = ( + args: PatchCoreV1NamespacedEndpointsApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/endpoints/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1NamespacedEvent( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1NamespacedEvent( + args: ListCoreV1NamespacedEventApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions> +): Promise +export function listCoreV1NamespacedEvent(args: any, options: any): any { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/events`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedEvent = ( + args: CreateCoreV1NamespacedEventApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/events`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedEvent = ( + args: DeleteCoreV1CollectionNamespacedEventApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/events`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedEvent = ( + args: ReadCoreV1NamespacedEventApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/events/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedEvent = ( + args: ReplaceCoreV1NamespacedEventApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/events/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedEvent = ( + args: DeleteCoreV1NamespacedEventApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/events/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedEvent = ( + args: PatchCoreV1NamespacedEventApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/events/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1NamespacedLimitRange( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1NamespacedLimitRange( + args: ListCoreV1NamespacedLimitRangeApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1NamespacedLimitRange(args: any, options: any): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/namespaces/${args['namespace']}/limitranges`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedLimitRange = ( + args: CreateCoreV1NamespacedLimitRangeApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/limitranges`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedLimitRange = ( + args: DeleteCoreV1CollectionNamespacedLimitRangeApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/limitranges`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedLimitRange = ( + args: ReadCoreV1NamespacedLimitRangeApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/limitranges/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedLimitRange = ( + args: ReplaceCoreV1NamespacedLimitRangeApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/limitranges/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedLimitRange = ( + args: DeleteCoreV1NamespacedLimitRangeApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/limitranges/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedLimitRange = ( + args: PatchCoreV1NamespacedLimitRangeApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/limitranges/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1NamespacedPersistentVolumeClaim( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listCoreV1NamespacedPersistentVolumeClaim( + args: ListCoreV1NamespacedPersistentVolumeClaimApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1NamespacedPersistentVolumeClaim( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/namespaces/${args['namespace']}/persistentvolumeclaims`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedPersistentVolumeClaim = ( + args: CreateCoreV1NamespacedPersistentVolumeClaimApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/persistentvolumeclaims`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedPersistentVolumeClaim = ( + args: DeleteCoreV1CollectionNamespacedPersistentVolumeClaimApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/persistentvolumeclaims`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedPersistentVolumeClaim = ( + args: ReadCoreV1NamespacedPersistentVolumeClaimApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/persistentvolumeclaims/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedPersistentVolumeClaim = ( + args: ReplaceCoreV1NamespacedPersistentVolumeClaimApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/persistentvolumeclaims/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedPersistentVolumeClaim = ( + args: DeleteCoreV1NamespacedPersistentVolumeClaimApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/persistentvolumeclaims/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedPersistentVolumeClaim = ( + args: PatchCoreV1NamespacedPersistentVolumeClaimApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/persistentvolumeclaims/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const readCoreV1NamespacedPersistentVolumeClaimStatus = ( + args: ReadCoreV1NamespacedPersistentVolumeClaimStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/persistentvolumeclaims/${args.name}/status`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedPersistentVolumeClaimStatus = ( + args: ReplaceCoreV1NamespacedPersistentVolumeClaimStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/persistentvolumeclaims/${args.name}/status`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const patchCoreV1NamespacedPersistentVolumeClaimStatus = ( + args: PatchCoreV1NamespacedPersistentVolumeClaimStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/persistentvolumeclaims/${args.name}/status`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1NamespacedPod( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1NamespacedPod( + args: ListCoreV1NamespacedPodApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions> +): Promise +export function listCoreV1NamespacedPod(args: any, options: any): any { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/pods`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedPod = ( + args: CreateCoreV1NamespacedPodApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/pods`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedPod = ( + args: DeleteCoreV1CollectionNamespacedPodApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedPod = ( + args: ReadCoreV1NamespacedPodApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedPod = ( + args: ReplaceCoreV1NamespacedPodApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedPod = ( + args: DeleteCoreV1NamespacedPodApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedPod = ( + args: PatchCoreV1NamespacedPodApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const connectCoreV1GetNamespacedPodAttach = ( + args: ConnectCoreV1GetNamespacedPodAttachApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/attach`, + params: { + container: args.container, + stderr: args.stderr, + stdin: args.stdin, + stdout: args.stdout, + tty: args.tty, + }, + }, + options + ) +} +export const connectCoreV1PostNamespacedPodAttach = ( + args: ConnectCoreV1PostNamespacedPodAttachApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/attach`, + method: 'POST', + params: { + container: args.container, + stderr: args.stderr, + stdin: args.stdin, + stdout: args.stdout, + tty: args.tty, + }, + }, + options + ) +} +export const createCoreV1NamespacedPodBinding = ( + args: CreateCoreV1NamespacedPodBindingApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/binding`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + pretty: args.pretty, + }, + }, + options + ) +} +export const readCoreV1NamespacedPodEphemeralcontainers = ( + args: ReadCoreV1NamespacedPodEphemeralcontainersApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/ephemeralcontainers`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedPodEphemeralcontainers = ( + args: ReplaceCoreV1NamespacedPodEphemeralcontainersApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/ephemeralcontainers`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const patchCoreV1NamespacedPodEphemeralcontainers = ( + args: PatchCoreV1NamespacedPodEphemeralcontainersApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/ephemeralcontainers`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const createCoreV1NamespacedPodEviction = ( + args: CreateCoreV1NamespacedPodEvictionApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/eviction`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + pretty: args.pretty, + }, + }, + options + ) +} +export const connectCoreV1GetNamespacedPodExec = ( + args: ConnectCoreV1GetNamespacedPodExecApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/exec`, + params: { + command: args.command, + container: args.container, + stderr: args.stderr, + stdin: args.stdin, + stdout: args.stdout, + tty: args.tty, + }, + }, + options + ) +} +export const connectCoreV1PostNamespacedPodExec = ( + args: ConnectCoreV1PostNamespacedPodExecApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/exec`, + method: 'POST', + params: { + command: args.command, + container: args.container, + stderr: args.stderr, + stdin: args.stdin, + stdout: args.stdout, + tty: args.tty, + }, + }, + options + ) +} +export const readCoreV1NamespacedPodLog = ( + args: ReadCoreV1NamespacedPodLogApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/log`, + params: { + container: args.container, + follow: args.follow, + insecureSkipTLSVerifyBackend: args.insecureSkipTlsVerifyBackend, + limitBytes: args.limitBytes, + pretty: args.pretty, + previous: args.previous, + sinceSeconds: args.sinceSeconds, + tailLines: args.tailLines, + timestamps: args.timestamps, + }, + }, + options + ) +} +export const connectCoreV1GetNamespacedPodPortforward = ( + args: ConnectCoreV1GetNamespacedPodPortforwardApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/portforward`, + params: { ports: args.ports }, + }, + options + ) +} +export const connectCoreV1PostNamespacedPodPortforward = ( + args: ConnectCoreV1PostNamespacedPodPortforwardApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/portforward`, + method: 'POST', + params: { ports: args.ports }, + }, + options + ) +} +export const connectCoreV1GetNamespacedPodProxy = ( + args: ConnectCoreV1GetNamespacedPodProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy`, + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1PutNamespacedPodProxy = ( + args: ConnectCoreV1PutNamespacedPodProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy`, + method: 'PUT', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1PostNamespacedPodProxy = ( + args: ConnectCoreV1PostNamespacedPodProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy`, + method: 'POST', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1DeleteNamespacedPodProxy = ( + args: ConnectCoreV1DeleteNamespacedPodProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy`, + method: 'DELETE', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1OptionsNamespacedPodProxy = ( + args: ConnectCoreV1OptionsNamespacedPodProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy`, + method: 'OPTIONS', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1HeadNamespacedPodProxy = ( + args: ConnectCoreV1HeadNamespacedPodProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy`, + method: 'HEAD', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1PatchNamespacedPodProxy = ( + args: ConnectCoreV1PatchNamespacedPodProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy`, + method: 'PATCH', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1GetNamespacedPodProxyWithPath = ( + args: ConnectCoreV1GetNamespacedPodProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy/${args.pathPath}`, + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1PutNamespacedPodProxyWithPath = ( + args: ConnectCoreV1PutNamespacedPodProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy/${args.pathPath}`, + method: 'PUT', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1PostNamespacedPodProxyWithPath = ( + args: ConnectCoreV1PostNamespacedPodProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy/${args.pathPath}`, + method: 'POST', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1DeleteNamespacedPodProxyWithPath = ( + args: ConnectCoreV1DeleteNamespacedPodProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy/${args.pathPath}`, + method: 'DELETE', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1OptionsNamespacedPodProxyWithPath = ( + args: ConnectCoreV1OptionsNamespacedPodProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy/${args.pathPath}`, + method: 'OPTIONS', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1HeadNamespacedPodProxyWithPath = ( + args: ConnectCoreV1HeadNamespacedPodProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy/${args.pathPath}`, + method: 'HEAD', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1PatchNamespacedPodProxyWithPath = ( + args: ConnectCoreV1PatchNamespacedPodProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/proxy/${args.pathPath}`, + method: 'PATCH', + params: { path: args.queryPath }, + }, + options + ) +} +export const readCoreV1NamespacedPodStatus = ( + args: ReadCoreV1NamespacedPodStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/status`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedPodStatus = ( + args: ReplaceCoreV1NamespacedPodStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/status`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const patchCoreV1NamespacedPodStatus = ( + args: PatchCoreV1NamespacedPodStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/pods/${args.name}/status`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1NamespacedPodTemplate( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1NamespacedPodTemplate( + args: ListCoreV1NamespacedPodTemplateApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1NamespacedPodTemplate(args: any, options: any): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/namespaces/${args['namespace']}/podtemplates`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedPodTemplate = ( + args: CreateCoreV1NamespacedPodTemplateApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/podtemplates`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedPodTemplate = ( + args: DeleteCoreV1CollectionNamespacedPodTemplateApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/podtemplates`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedPodTemplate = ( + args: ReadCoreV1NamespacedPodTemplateApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/podtemplates/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedPodTemplate = ( + args: ReplaceCoreV1NamespacedPodTemplateApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/podtemplates/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedPodTemplate = ( + args: DeleteCoreV1NamespacedPodTemplateApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/podtemplates/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedPodTemplate = ( + args: PatchCoreV1NamespacedPodTemplateApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/podtemplates/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1NamespacedReplicationController( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listCoreV1NamespacedReplicationController( + args: ListCoreV1NamespacedReplicationControllerApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1NamespacedReplicationController( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedReplicationController = ( + args: CreateCoreV1NamespacedReplicationControllerApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedReplicationController = ( + args: DeleteCoreV1CollectionNamespacedReplicationControllerApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedReplicationController = ( + args: ReadCoreV1NamespacedReplicationControllerApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedReplicationController = ( + args: ReplaceCoreV1NamespacedReplicationControllerApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedReplicationController = ( + args: DeleteCoreV1NamespacedReplicationControllerApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedReplicationController = ( + args: PatchCoreV1NamespacedReplicationControllerApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const readCoreV1NamespacedReplicationControllerScale = ( + args: ReadCoreV1NamespacedReplicationControllerScaleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers/${args.name}/scale`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedReplicationControllerScale = ( + args: ReplaceCoreV1NamespacedReplicationControllerScaleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers/${args.name}/scale`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const patchCoreV1NamespacedReplicationControllerScale = ( + args: PatchCoreV1NamespacedReplicationControllerScaleApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers/${args.name}/scale`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const readCoreV1NamespacedReplicationControllerStatus = ( + args: ReadCoreV1NamespacedReplicationControllerStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers/${args.name}/status`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedReplicationControllerStatus = ( + args: ReplaceCoreV1NamespacedReplicationControllerStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers/${args.name}/status`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const patchCoreV1NamespacedReplicationControllerStatus = ( + args: PatchCoreV1NamespacedReplicationControllerStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/replicationcontrollers/${args.name}/status`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1NamespacedResourceQuota( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1NamespacedResourceQuota( + args: ListCoreV1NamespacedResourceQuotaApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1NamespacedResourceQuota( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/namespaces/${args['namespace']}/resourcequotas`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedResourceQuota = ( + args: CreateCoreV1NamespacedResourceQuotaApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/resourcequotas`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedResourceQuota = ( + args: DeleteCoreV1CollectionNamespacedResourceQuotaApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/resourcequotas`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedResourceQuota = ( + args: ReadCoreV1NamespacedResourceQuotaApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/resourcequotas/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedResourceQuota = ( + args: ReplaceCoreV1NamespacedResourceQuotaApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/resourcequotas/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedResourceQuota = ( + args: DeleteCoreV1NamespacedResourceQuotaApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/resourcequotas/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedResourceQuota = ( + args: PatchCoreV1NamespacedResourceQuotaApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/resourcequotas/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const readCoreV1NamespacedResourceQuotaStatus = ( + args: ReadCoreV1NamespacedResourceQuotaStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/resourcequotas/${args.name}/status`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedResourceQuotaStatus = ( + args: ReplaceCoreV1NamespacedResourceQuotaStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/resourcequotas/${args.name}/status`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const patchCoreV1NamespacedResourceQuotaStatus = ( + args: PatchCoreV1NamespacedResourceQuotaStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/resourcequotas/${args.name}/status`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1NamespacedSecret( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1NamespacedSecret( + args: ListCoreV1NamespacedSecretApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1NamespacedSecret(args: any, options: any): any { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/secrets`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedSecret = ( + args: CreateCoreV1NamespacedSecretApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/secrets`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedSecret = ( + args: DeleteCoreV1CollectionNamespacedSecretApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/secrets`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedSecret = ( + args: ReadCoreV1NamespacedSecretApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/secrets/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedSecret = ( + args: ReplaceCoreV1NamespacedSecretApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/secrets/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedSecret = ( + args: DeleteCoreV1NamespacedSecretApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/secrets/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedSecret = ( + args: PatchCoreV1NamespacedSecretApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/secrets/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1NamespacedServiceAccount( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1NamespacedServiceAccount( + args: ListCoreV1NamespacedServiceAccountApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1NamespacedServiceAccount( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/namespaces/${args['namespace']}/serviceaccounts`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedServiceAccount = ( + args: CreateCoreV1NamespacedServiceAccountApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/serviceaccounts`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedServiceAccount = ( + args: DeleteCoreV1CollectionNamespacedServiceAccountApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/serviceaccounts`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedServiceAccount = ( + args: ReadCoreV1NamespacedServiceAccountApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/serviceaccounts/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedServiceAccount = ( + args: ReplaceCoreV1NamespacedServiceAccountApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/serviceaccounts/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedServiceAccount = ( + args: DeleteCoreV1NamespacedServiceAccountApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/serviceaccounts/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedServiceAccount = ( + args: PatchCoreV1NamespacedServiceAccountApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/serviceaccounts/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const createCoreV1NamespacedServiceAccountToken = ( + args: CreateCoreV1NamespacedServiceAccountTokenApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/serviceaccounts/${args.name}/token`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + pretty: args.pretty, + }, + }, + options + ) +} +export function listCoreV1NamespacedService( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1NamespacedService( + args: ListCoreV1NamespacedServiceApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1NamespacedService(args: any, options: any): any { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/services`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1NamespacedService = ( + args: CreateCoreV1NamespacedServiceApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNamespacedService = ( + args: DeleteCoreV1CollectionNamespacedServiceApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1NamespacedService = ( + args: ReadCoreV1NamespacedServiceApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedService = ( + args: ReplaceCoreV1NamespacedServiceApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1NamespacedService = ( + args: DeleteCoreV1NamespacedServiceApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1NamespacedService = ( + args: PatchCoreV1NamespacedServiceApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const connectCoreV1GetNamespacedServiceProxy = ( + args: ConnectCoreV1GetNamespacedServiceProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy`, + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1PutNamespacedServiceProxy = ( + args: ConnectCoreV1PutNamespacedServiceProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy`, + method: 'PUT', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1PostNamespacedServiceProxy = ( + args: ConnectCoreV1PostNamespacedServiceProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy`, + method: 'POST', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1DeleteNamespacedServiceProxy = ( + args: ConnectCoreV1DeleteNamespacedServiceProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy`, + method: 'DELETE', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1OptionsNamespacedServiceProxy = ( + args: ConnectCoreV1OptionsNamespacedServiceProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy`, + method: 'OPTIONS', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1HeadNamespacedServiceProxy = ( + args: ConnectCoreV1HeadNamespacedServiceProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy`, + method: 'HEAD', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1PatchNamespacedServiceProxy = ( + args: ConnectCoreV1PatchNamespacedServiceProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy`, + method: 'PATCH', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1GetNamespacedServiceProxyWithPath = ( + args: ConnectCoreV1GetNamespacedServiceProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy/${args.pathPath}`, + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1PutNamespacedServiceProxyWithPath = ( + args: ConnectCoreV1PutNamespacedServiceProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy/${args.pathPath}`, + method: 'PUT', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1PostNamespacedServiceProxyWithPath = ( + args: ConnectCoreV1PostNamespacedServiceProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy/${args.pathPath}`, + method: 'POST', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1DeleteNamespacedServiceProxyWithPath = ( + args: ConnectCoreV1DeleteNamespacedServiceProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy/${args.pathPath}`, + method: 'DELETE', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1OptionsNamespacedServiceProxyWithPath = ( + args: ConnectCoreV1OptionsNamespacedServiceProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy/${args.pathPath}`, + method: 'OPTIONS', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1HeadNamespacedServiceProxyWithPath = ( + args: ConnectCoreV1HeadNamespacedServiceProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy/${args.pathPath}`, + method: 'HEAD', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1PatchNamespacedServiceProxyWithPath = ( + args: ConnectCoreV1PatchNamespacedServiceProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/proxy/${args.pathPath}`, + method: 'PATCH', + params: { path: args.queryPath }, + }, + options + ) +} +export const readCoreV1NamespacedServiceStatus = ( + args: ReadCoreV1NamespacedServiceStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/status`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespacedServiceStatus = ( + args: ReplaceCoreV1NamespacedServiceStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/status`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const patchCoreV1NamespacedServiceStatus = ( + args: PatchCoreV1NamespacedServiceStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args['namespace']}/services/${args.name}/status`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const readCoreV1Namespace = ( + args: ReadCoreV1NamespaceApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1Namespace = ( + args: ReplaceCoreV1NamespaceApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1Namespace = ( + args: DeleteCoreV1NamespaceApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1Namespace = ( + args: PatchCoreV1NamespaceApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const replaceCoreV1NamespaceFinalize = ( + args: ReplaceCoreV1NamespaceFinalizeApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/namespaces/${args.name}/finalize`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + pretty: args.pretty, + }, + }, + options + ) +} +export const readCoreV1NamespaceStatus = ( + args: ReadCoreV1NamespaceStatusApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args.name}/status`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NamespaceStatus = ( + args: ReplaceCoreV1NamespaceStatusApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args.name}/status`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const patchCoreV1NamespaceStatus = ( + args: PatchCoreV1NamespaceStatusApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/namespaces/${args.name}/status`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1Node( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1Node( + args: ListCoreV1NodeApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions> +): Promise +export function listCoreV1Node(args: any, options: any): any { + return apiClient>( + { + path: `/api/v1/nodes`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1Node = ( + args: CreateCoreV1NodeApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionNode = ( + args: DeleteCoreV1CollectionNodeApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1Node = ( + args: ReadCoreV1NodeApiArg, + options?: Options +) => { + return apiClient>( + { path: `/api/v1/nodes/${args.name}`, params: { pretty: args.pretty } }, + options + ) +} +export const replaceCoreV1Node = ( + args: ReplaceCoreV1NodeApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1Node = ( + args: DeleteCoreV1NodeApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1Node = ( + args: PatchCoreV1NodeApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const connectCoreV1GetNodeProxy = ( + args: ConnectCoreV1GetNodeProxyApiArg, + options?: Options +) => { + return apiClient>( + { path: `/api/v1/nodes/${args.name}/proxy`, params: { path: args.path } }, + options + ) +} +export const connectCoreV1PutNodeProxy = ( + args: ConnectCoreV1PutNodeProxyApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes/${args.name}/proxy`, + method: 'PUT', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1PostNodeProxy = ( + args: ConnectCoreV1PostNodeProxyApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes/${args.name}/proxy`, + method: 'POST', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1DeleteNodeProxy = ( + args: ConnectCoreV1DeleteNodeProxyApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes/${args.name}/proxy`, + method: 'DELETE', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1OptionsNodeProxy = ( + args: ConnectCoreV1OptionsNodeProxyApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/nodes/${args.name}/proxy`, + method: 'OPTIONS', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1HeadNodeProxy = ( + args: ConnectCoreV1HeadNodeProxyApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes/${args.name}/proxy`, + method: 'HEAD', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1PatchNodeProxy = ( + args: ConnectCoreV1PatchNodeProxyApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes/${args.name}/proxy`, + method: 'PATCH', + params: { path: args.path }, + }, + options + ) +} +export const connectCoreV1GetNodeProxyWithPath = ( + args: ConnectCoreV1GetNodeProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/nodes/${args.name}/proxy/${args.pathPath}`, + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1PutNodeProxyWithPath = ( + args: ConnectCoreV1PutNodeProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/nodes/${args.name}/proxy/${args.pathPath}`, + method: 'PUT', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1PostNodeProxyWithPath = ( + args: ConnectCoreV1PostNodeProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/nodes/${args.name}/proxy/${args.pathPath}`, + method: 'POST', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1DeleteNodeProxyWithPath = ( + args: ConnectCoreV1DeleteNodeProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/nodes/${args.name}/proxy/${args.pathPath}`, + method: 'DELETE', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1OptionsNodeProxyWithPath = ( + args: ConnectCoreV1OptionsNodeProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/nodes/${args.name}/proxy/${args.pathPath}`, + method: 'OPTIONS', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1HeadNodeProxyWithPath = ( + args: ConnectCoreV1HeadNodeProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/nodes/${args.name}/proxy/${args.pathPath}`, + method: 'HEAD', + params: { path: args.queryPath }, + }, + options + ) +} +export const connectCoreV1PatchNodeProxyWithPath = ( + args: ConnectCoreV1PatchNodeProxyWithPathApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/nodes/${args.name}/proxy/${args.pathPath}`, + method: 'PATCH', + params: { path: args.queryPath }, + }, + options + ) +} +export const readCoreV1NodeStatus = ( + args: ReadCoreV1NodeStatusApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes/${args.name}/status`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1NodeStatus = ( + args: ReplaceCoreV1NodeStatusApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes/${args.name}/status`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const patchCoreV1NodeStatus = ( + args: PatchCoreV1NodeStatusApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/nodes/${args.name}/status`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1PersistentVolumeClaimForAllNamespaces( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listCoreV1PersistentVolumeClaimForAllNamespaces( + args: ListCoreV1PersistentVolumeClaimForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1PersistentVolumeClaimForAllNamespaces( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/persistentvolumeclaims`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listCoreV1PersistentVolume( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1PersistentVolume( + args: ListCoreV1PersistentVolumeApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1PersistentVolume(args: any, options: any): any { + return apiClient>( + { + path: `/api/v1/persistentvolumes`, + params: { + pretty: args.pretty, + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const createCoreV1PersistentVolume = ( + args: CreateCoreV1PersistentVolumeApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/persistentvolumes`, + method: 'POST', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1CollectionPersistentVolume = ( + args: DeleteCoreV1CollectionPersistentVolumeApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/persistentvolumes`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + continue: args['continue'], + dryRun: args.dryRun, + fieldSelector: args.fieldSelector, + gracePeriodSeconds: args.gracePeriodSeconds, + labelSelector: args.labelSelector, + limit: args.limit, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + }, + }, + options + ) +} +export const readCoreV1PersistentVolume = ( + args: ReadCoreV1PersistentVolumeApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/persistentvolumes/${args.name}`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1PersistentVolume = ( + args: ReplaceCoreV1PersistentVolumeApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/persistentvolumes/${args.name}`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const deleteCoreV1PersistentVolume = ( + args: DeleteCoreV1PersistentVolumeApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/persistentvolumes/${args.name}`, + method: 'DELETE', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + gracePeriodSeconds: args.gracePeriodSeconds, + orphanDependents: args.orphanDependents, + propagationPolicy: args.propagationPolicy, + }, + }, + options + ) +} +export const patchCoreV1PersistentVolume = ( + args: PatchCoreV1PersistentVolumeApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/persistentvolumes/${args.name}`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export const readCoreV1PersistentVolumeStatus = ( + args: ReadCoreV1PersistentVolumeStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/persistentvolumes/${args.name}/status`, + params: { pretty: args.pretty }, + }, + options + ) +} +export const replaceCoreV1PersistentVolumeStatus = ( + args: ReplaceCoreV1PersistentVolumeStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/persistentvolumes/${args.name}/status`, + method: 'PUT', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + }, + }, + options + ) +} +export const patchCoreV1PersistentVolumeStatus = ( + args: PatchCoreV1PersistentVolumeStatusApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredGet + >( + { + path: `/api/v1/persistentvolumes/${args.name}/status`, + method: 'PATCH', + body: args.body, + contentType: args.contentType, + params: { + pretty: args.pretty, + dryRun: args.dryRun, + fieldManager: args.fieldManager, + fieldValidation: args.fieldValidation, + force: args.force, + }, + }, + options + ) +} +export function listCoreV1PodForAllNamespaces( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1PodForAllNamespaces( + args: ListCoreV1PodForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1PodForAllNamespaces(args: any, options: any): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/pods`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listCoreV1PodTemplateForAllNamespaces( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listCoreV1PodTemplateForAllNamespaces( + args: ListCoreV1PodTemplateForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1PodTemplateForAllNamespaces( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/podtemplates`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listCoreV1ReplicationControllerForAllNamespaces( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listCoreV1ReplicationControllerForAllNamespaces( + args: ListCoreV1ReplicationControllerForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1ReplicationControllerForAllNamespaces( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/replicationcontrollers`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listCoreV1ResourceQuotaForAllNamespaces( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listCoreV1ResourceQuotaForAllNamespaces( + args: ListCoreV1ResourceQuotaForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1ResourceQuotaForAllNamespaces( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/resourcequotas`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listCoreV1SecretForAllNamespaces( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1SecretForAllNamespaces( + args: ListCoreV1SecretForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1SecretForAllNamespaces(args: any, options: any): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/secrets`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listCoreV1ServiceAccountForAllNamespaces( + args: NoWatch, + options?: Options +): Promise< + MinimumRequiredList +> +export function listCoreV1ServiceAccountForAllNamespaces( + args: ListCoreV1ServiceAccountForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1ServiceAccountForAllNamespaces( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/serviceaccounts`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export function listCoreV1ServiceForAllNamespaces( + args: NoWatch, + options?: Options +): Promise> +export function listCoreV1ServiceForAllNamespaces( + args: ListCoreV1ServiceForAllNamespacesApiArg & { + watch: true + }, + options: Options & + WatchExtraOptions< + MinimumRequiredList + > +): Promise +export function listCoreV1ServiceForAllNamespaces( + args: any, + options: any +): any { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/services`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1ConfigMapListForAllNamespaces = ( + args: WatchCoreV1ConfigMapListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/configmaps`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1EndpointsListForAllNamespaces = ( + args: WatchCoreV1EndpointsListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/endpoints`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1EventListForAllNamespaces = ( + args: WatchCoreV1EventListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/events`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1LimitRangeListForAllNamespaces = ( + args: WatchCoreV1LimitRangeListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/limitranges`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespaceList = ( + args: WatchCoreV1NamespaceListApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/watch/namespaces`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedConfigMapList = ( + args: WatchCoreV1NamespacedConfigMapListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/configmaps`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedConfigMap = ( + args: WatchCoreV1NamespacedConfigMapApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/configmaps/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedEndpointsList = ( + args: WatchCoreV1NamespacedEndpointsListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/endpoints`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedEndpoints = ( + args: WatchCoreV1NamespacedEndpointsApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/endpoints/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedEventList = ( + args: WatchCoreV1NamespacedEventListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/events`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedEvent = ( + args: WatchCoreV1NamespacedEventApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/events/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedLimitRangeList = ( + args: WatchCoreV1NamespacedLimitRangeListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/limitranges`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedLimitRange = ( + args: WatchCoreV1NamespacedLimitRangeApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/limitranges/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedPersistentVolumeClaimList = ( + args: WatchCoreV1NamespacedPersistentVolumeClaimListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/persistentvolumeclaims`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedPersistentVolumeClaim = ( + args: WatchCoreV1NamespacedPersistentVolumeClaimApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/persistentvolumeclaims/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedPodList = ( + args: WatchCoreV1NamespacedPodListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/pods`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedPod = ( + args: WatchCoreV1NamespacedPodApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/pods/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedPodTemplateList = ( + args: WatchCoreV1NamespacedPodTemplateListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/podtemplates`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedPodTemplate = ( + args: WatchCoreV1NamespacedPodTemplateApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/podtemplates/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedReplicationControllerList = ( + args: WatchCoreV1NamespacedReplicationControllerListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/replicationcontrollers`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedReplicationController = ( + args: WatchCoreV1NamespacedReplicationControllerApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/replicationcontrollers/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedResourceQuotaList = ( + args: WatchCoreV1NamespacedResourceQuotaListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/resourcequotas`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedResourceQuota = ( + args: WatchCoreV1NamespacedResourceQuotaApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/resourcequotas/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedSecretList = ( + args: WatchCoreV1NamespacedSecretListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/secrets`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedSecret = ( + args: WatchCoreV1NamespacedSecretApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/secrets/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedServiceAccountList = ( + args: WatchCoreV1NamespacedServiceAccountListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/serviceaccounts`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedServiceAccount = ( + args: WatchCoreV1NamespacedServiceAccountApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/serviceaccounts/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedServiceList = ( + args: WatchCoreV1NamespacedServiceListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/services`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NamespacedService = ( + args: WatchCoreV1NamespacedServiceApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/namespaces/${args['namespace']}/services/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1Namespace = ( + args: WatchCoreV1NamespaceApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/watch/namespaces/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1NodeList = ( + args: WatchCoreV1NodeListApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/watch/nodes`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1Node = ( + args: WatchCoreV1NodeApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/watch/nodes/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1PersistentVolumeClaimListForAllNamespaces = ( + args: WatchCoreV1PersistentVolumeClaimListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/persistentvolumeclaims`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1PersistentVolumeList = ( + args: WatchCoreV1PersistentVolumeListApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/persistentvolumes`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1PersistentVolume = ( + args: WatchCoreV1PersistentVolumeApiArg, + options?: Options +) => { + return apiClient>( + { + path: `/api/v1/watch/persistentvolumes/${args.name}`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1PodListForAllNamespaces = ( + args: WatchCoreV1PodListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/pods`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1PodTemplateListForAllNamespaces = ( + args: WatchCoreV1PodTemplateListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/podtemplates`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1ReplicationControllerListForAllNamespaces = ( + args: WatchCoreV1ReplicationControllerListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/replicationcontrollers`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1ResourceQuotaListForAllNamespaces = ( + args: WatchCoreV1ResourceQuotaListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/resourcequotas`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1SecretListForAllNamespaces = ( + args: WatchCoreV1SecretListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/secrets`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1ServiceAccountListForAllNamespaces = ( + args: WatchCoreV1ServiceAccountListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/serviceaccounts`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export const watchCoreV1ServiceListForAllNamespaces = ( + args: WatchCoreV1ServiceListForAllNamespacesApiArg, + options?: Options +) => { + return apiClient< + MinimumRequiredList + >( + { + path: `/api/v1/watch/services`, + params: { + allowWatchBookmarks: args.allowWatchBookmarks, + continue: args['continue'], + fieldSelector: args.fieldSelector, + labelSelector: args.labelSelector, + limit: args.limit, + pretty: args.pretty, + resourceVersion: args.resourceVersion, + resourceVersionMatch: args.resourceVersionMatch, + sendInitialEvents: args.sendInitialEvents, + timeoutSeconds: args.timeoutSeconds, + watch: args.watch, + }, + }, + options + ) +} +export type GetCoreV1ApiResourcesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1ApiResourceList +export type GetCoreV1ApiResourcesApiArg = void +export type ListCoreV1ComponentStatusApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ComponentStatusList +export type ListCoreV1ComponentStatusApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ReadCoreV1ComponentStatusApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ComponentStatus +export type ReadCoreV1ComponentStatusApiArg = { + /** name of the ComponentStatus */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ListCoreV1ConfigMapForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ConfigMapList +export type ListCoreV1ConfigMapForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListCoreV1EndpointsForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1EndpointsList +export type ListCoreV1EndpointsForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListCoreV1EventForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1EventList +export type ListCoreV1EventForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListCoreV1LimitRangeForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1LimitRangeList +export type ListCoreV1LimitRangeForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListCoreV1NamespaceApiResponse = + /** status 200 OK */ IoK8SApiCoreV1NamespaceList +export type ListCoreV1NamespaceApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespaceApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1Namespace + | /** status 201 Created */ IoK8SApiCoreV1Namespace + | /** status 202 Accepted */ IoK8SApiCoreV1Namespace +export type CreateCoreV1NamespaceApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Namespace +} +export type CreateCoreV1NamespacedBindingApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1Binding + | /** status 201 Created */ IoK8SApiCoreV1Binding + | /** status 202 Accepted */ IoK8SApiCoreV1Binding +export type CreateCoreV1NamespacedBindingApiArg = { + /** When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Binding +} +export type ListCoreV1NamespacedConfigMapApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ConfigMapList +export type ListCoreV1NamespacedConfigMapApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedConfigMapApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ConfigMap + | /** status 201 Created */ IoK8SApiCoreV1ConfigMap + | /** status 202 Accepted */ IoK8SApiCoreV1ConfigMap +export type CreateCoreV1NamespacedConfigMapApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1ConfigMap +} +export type DeleteCoreV1CollectionNamespacedConfigMapApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedConfigMapApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedConfigMapApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ConfigMap +export type ReadCoreV1NamespacedConfigMapApiArg = { + /** name of the ConfigMap */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedConfigMapApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1ConfigMap | /** status 201 Created */ IoK8SApiCoreV1ConfigMap +export type ReplaceCoreV1NamespacedConfigMapApiArg = { + /** name of the ConfigMap */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1ConfigMap +} +export type DeleteCoreV1NamespacedConfigMapApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1NamespacedConfigMapApiArg = { + /** name of the ConfigMap */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedConfigMapApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1ConfigMap | /** status 201 Created */ IoK8SApiCoreV1ConfigMap +export type PatchCoreV1NamespacedConfigMapApiArg = { + /** name of the ConfigMap */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1ConfigMap & { + apiVersion: 'v1' + kind: 'ConfigMap' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1ConfigMap + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1ConfigMap + } +) +export type ListCoreV1NamespacedEndpointsApiResponse = + /** status 200 OK */ IoK8SApiCoreV1EndpointsList +export type ListCoreV1NamespacedEndpointsApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedEndpointsApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1Endpoints + | /** status 201 Created */ IoK8SApiCoreV1Endpoints + | /** status 202 Accepted */ IoK8SApiCoreV1Endpoints +export type CreateCoreV1NamespacedEndpointsApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Endpoints +} +export type DeleteCoreV1CollectionNamespacedEndpointsApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedEndpointsApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedEndpointsApiResponse = + /** status 200 OK */ IoK8SApiCoreV1Endpoints +export type ReadCoreV1NamespacedEndpointsApiArg = { + /** name of the Endpoints */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedEndpointsApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Endpoints | /** status 201 Created */ IoK8SApiCoreV1Endpoints +export type ReplaceCoreV1NamespacedEndpointsApiArg = { + /** name of the Endpoints */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Endpoints +} +export type DeleteCoreV1NamespacedEndpointsApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1NamespacedEndpointsApiArg = { + /** name of the Endpoints */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedEndpointsApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Endpoints | /** status 201 Created */ IoK8SApiCoreV1Endpoints +export type PatchCoreV1NamespacedEndpointsApiArg = { + /** name of the Endpoints */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Endpoints & { + apiVersion: 'v1' + kind: 'Endpoints' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Endpoints + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Endpoints + } +) +export type ListCoreV1NamespacedEventApiResponse = + /** status 200 OK */ IoK8SApiCoreV1EventList +export type ListCoreV1NamespacedEventApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedEventApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1Event + | /** status 201 Created */ IoK8SApiCoreV1Event + | /** status 202 Accepted */ IoK8SApiCoreV1Event +export type CreateCoreV1NamespacedEventApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Event +} +export type DeleteCoreV1CollectionNamespacedEventApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedEventApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedEventApiResponse = + /** status 200 OK */ IoK8SApiCoreV1Event +export type ReadCoreV1NamespacedEventApiArg = { + /** name of the Event */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedEventApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Event | /** status 201 Created */ IoK8SApiCoreV1Event +export type ReplaceCoreV1NamespacedEventApiArg = { + /** name of the Event */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Event +} +export type DeleteCoreV1NamespacedEventApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1NamespacedEventApiArg = { + /** name of the Event */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedEventApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Event | /** status 201 Created */ IoK8SApiCoreV1Event +export type PatchCoreV1NamespacedEventApiArg = { + /** name of the Event */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Event & { + apiVersion: 'v1' + kind: 'Event' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Event + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Event + } +) +export type ListCoreV1NamespacedLimitRangeApiResponse = + /** status 200 OK */ IoK8SApiCoreV1LimitRangeList +export type ListCoreV1NamespacedLimitRangeApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedLimitRangeApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1LimitRange + | /** status 201 Created */ IoK8SApiCoreV1LimitRange + | /** status 202 Accepted */ IoK8SApiCoreV1LimitRange +export type CreateCoreV1NamespacedLimitRangeApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1LimitRange +} +export type DeleteCoreV1CollectionNamespacedLimitRangeApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedLimitRangeApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedLimitRangeApiResponse = + /** status 200 OK */ IoK8SApiCoreV1LimitRange +export type ReadCoreV1NamespacedLimitRangeApiArg = { + /** name of the LimitRange */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedLimitRangeApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1LimitRange | /** status 201 Created */ IoK8SApiCoreV1LimitRange +export type ReplaceCoreV1NamespacedLimitRangeApiArg = { + /** name of the LimitRange */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1LimitRange +} +export type DeleteCoreV1NamespacedLimitRangeApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1NamespacedLimitRangeApiArg = { + /** name of the LimitRange */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedLimitRangeApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1LimitRange | /** status 201 Created */ IoK8SApiCoreV1LimitRange +export type PatchCoreV1NamespacedLimitRangeApiArg = { + /** name of the LimitRange */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1LimitRange & { + apiVersion: 'v1' + kind: 'LimitRange' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1LimitRange + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1LimitRange + } +) +export type ListCoreV1NamespacedPersistentVolumeClaimApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PersistentVolumeClaimList +export type ListCoreV1NamespacedPersistentVolumeClaimApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedPersistentVolumeClaimApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolumeClaim + | /** status 201 Created */ IoK8SApiCoreV1PersistentVolumeClaim + | /** status 202 Accepted */ IoK8SApiCoreV1PersistentVolumeClaim +export type CreateCoreV1NamespacedPersistentVolumeClaimApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1PersistentVolumeClaim +} +export type DeleteCoreV1CollectionNamespacedPersistentVolumeClaimApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedPersistentVolumeClaimApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedPersistentVolumeClaimApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PersistentVolumeClaim +export type ReadCoreV1NamespacedPersistentVolumeClaimApiArg = { + /** name of the PersistentVolumeClaim */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedPersistentVolumeClaimApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolumeClaim + | /** status 201 Created */ IoK8SApiCoreV1PersistentVolumeClaim +export type ReplaceCoreV1NamespacedPersistentVolumeClaimApiArg = { + /** name of the PersistentVolumeClaim */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1PersistentVolumeClaim +} +export type DeleteCoreV1NamespacedPersistentVolumeClaimApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolumeClaim + | /** status 202 Accepted */ IoK8SApiCoreV1PersistentVolumeClaim +export type DeleteCoreV1NamespacedPersistentVolumeClaimApiArg = { + /** name of the PersistentVolumeClaim */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedPersistentVolumeClaimApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolumeClaim + | /** status 201 Created */ IoK8SApiCoreV1PersistentVolumeClaim +export type PatchCoreV1NamespacedPersistentVolumeClaimApiArg = { + /** name of the PersistentVolumeClaim */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1PersistentVolumeClaim & { + apiVersion: 'v1' + kind: 'PersistentVolumeClaim' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1PersistentVolumeClaim + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1PersistentVolumeClaim + } +) +export type ReadCoreV1NamespacedPersistentVolumeClaimStatusApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PersistentVolumeClaim +export type ReadCoreV1NamespacedPersistentVolumeClaimStatusApiArg = { + /** name of the PersistentVolumeClaim */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedPersistentVolumeClaimStatusApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolumeClaim + | /** status 201 Created */ IoK8SApiCoreV1PersistentVolumeClaim +export type ReplaceCoreV1NamespacedPersistentVolumeClaimStatusApiArg = { + /** name of the PersistentVolumeClaim */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1PersistentVolumeClaim +} +export type PatchCoreV1NamespacedPersistentVolumeClaimStatusApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolumeClaim + | /** status 201 Created */ IoK8SApiCoreV1PersistentVolumeClaim +export type PatchCoreV1NamespacedPersistentVolumeClaimStatusApiArg = { + /** name of the PersistentVolumeClaim */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1PersistentVolumeClaim + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1PersistentVolumeClaim + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1PersistentVolumeClaim + } +) +export type ListCoreV1NamespacedPodApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PodList +export type ListCoreV1NamespacedPodApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedPodApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1Pod + | /** status 201 Created */ IoK8SApiCoreV1Pod + | /** status 202 Accepted */ IoK8SApiCoreV1Pod +export type CreateCoreV1NamespacedPodApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Pod +} +export type DeleteCoreV1CollectionNamespacedPodApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedPodApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedPodApiResponse = + /** status 200 OK */ IoK8SApiCoreV1Pod +export type ReadCoreV1NamespacedPodApiArg = { + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedPodApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Pod | /** status 201 Created */ IoK8SApiCoreV1Pod +export type ReplaceCoreV1NamespacedPodApiArg = { + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Pod +} +export type DeleteCoreV1NamespacedPodApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Pod | /** status 202 Accepted */ IoK8SApiCoreV1Pod +export type DeleteCoreV1NamespacedPodApiArg = { + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedPodApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Pod | /** status 201 Created */ IoK8SApiCoreV1Pod +export type PatchCoreV1NamespacedPodApiArg = { + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Pod & { + apiVersion: 'v1' + kind: 'Pod' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Pod + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Pod + } +) +export type ConnectCoreV1GetNamespacedPodAttachApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1GetNamespacedPodAttachApiArg = { + /** The container in which to execute the command. Defaults to only container if there is only one container in the pod. */ + container?: string + /** name of the PodAttachOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** Stderr if true indicates that stderr is to be redirected for the attach call. Defaults to true. */ + stderr?: boolean + /** Stdin if true, redirects the standard input stream of the pod for this call. Defaults to false. */ + stdin?: boolean + /** Stdout if true indicates that stdout is to be redirected for the attach call. Defaults to true. */ + stdout?: boolean + /** 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. */ + tty?: boolean +} +export type ConnectCoreV1PostNamespacedPodAttachApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PostNamespacedPodAttachApiArg = { + /** The container in which to execute the command. Defaults to only container if there is only one container in the pod. */ + container?: string + /** name of the PodAttachOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** Stderr if true indicates that stderr is to be redirected for the attach call. Defaults to true. */ + stderr?: boolean + /** Stdin if true, redirects the standard input stream of the pod for this call. Defaults to false. */ + stdin?: boolean + /** Stdout if true indicates that stdout is to be redirected for the attach call. Defaults to true. */ + stdout?: boolean + /** 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. */ + tty?: boolean +} +export type CreateCoreV1NamespacedPodBindingApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1Binding + | /** status 201 Created */ IoK8SApiCoreV1Binding + | /** status 202 Accepted */ IoK8SApiCoreV1Binding +export type CreateCoreV1NamespacedPodBindingApiArg = { + /** When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** name of the Binding */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Binding +} +export type ReadCoreV1NamespacedPodEphemeralcontainersApiResponse = + /** status 200 OK */ IoK8SApiCoreV1Pod +export type ReadCoreV1NamespacedPodEphemeralcontainersApiArg = { + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedPodEphemeralcontainersApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Pod | /** status 201 Created */ IoK8SApiCoreV1Pod +export type ReplaceCoreV1NamespacedPodEphemeralcontainersApiArg = { + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Pod +} +export type PatchCoreV1NamespacedPodEphemeralcontainersApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Pod | /** status 201 Created */ IoK8SApiCoreV1Pod +export type PatchCoreV1NamespacedPodEphemeralcontainersApiArg = { + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Pod & { + apiVersion: 'v1/namespaces' + kind: 'Pod' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Pod + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Pod + } +) +export type CreateCoreV1NamespacedPodEvictionApiResponse = + /** status 200 OK */ + | IoK8SApiPolicyV1Eviction + | /** status 201 Created */ IoK8SApiPolicyV1Eviction + | /** status 202 Accepted */ IoK8SApiPolicyV1Eviction +export type CreateCoreV1NamespacedPodEvictionApiArg = { + /** When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** name of the Eviction */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} & { + contentType?: string + body: IoK8SApiPolicyV1Eviction +} +export type ConnectCoreV1GetNamespacedPodExecApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1GetNamespacedPodExecApiArg = { + /** Command is the remote command to execute. argv array. Not executed within a shell. */ + command?: string + /** Container in which to execute the command. Defaults to only container if there is only one container in the pod. */ + container?: string + /** name of the PodExecOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** Redirect the standard error stream of the pod for this call. */ + stderr?: boolean + /** Redirect the standard input stream of the pod for this call. Defaults to false. */ + stdin?: boolean + /** Redirect the standard output stream of the pod for this call. */ + stdout?: boolean + /** TTY if true indicates that a tty will be allocated for the exec call. Defaults to false. */ + tty?: boolean +} +export type ConnectCoreV1PostNamespacedPodExecApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PostNamespacedPodExecApiArg = { + /** Command is the remote command to execute. argv array. Not executed within a shell. */ + command?: string + /** Container in which to execute the command. Defaults to only container if there is only one container in the pod. */ + container?: string + /** name of the PodExecOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** Redirect the standard error stream of the pod for this call. */ + stderr?: boolean + /** Redirect the standard input stream of the pod for this call. Defaults to false. */ + stdin?: boolean + /** Redirect the standard output stream of the pod for this call. */ + stdout?: boolean + /** TTY if true indicates that a tty will be allocated for the exec call. Defaults to false. */ + tty?: boolean +} +export type ReadCoreV1NamespacedPodLogApiResponse = /** status 200 OK */ string +export type ReadCoreV1NamespacedPodLogApiArg = { + /** The container for which to stream logs. Defaults to only container if there is one container in the pod. */ + container?: string + /** Follow the log stream of the pod. Defaults to false. */ + follow?: boolean + /** 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). */ + insecureSkipTlsVerifyBackend?: boolean + /** 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. */ + limitBytes?: number + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** Return previous terminated container logs. Defaults to false. */ + previous?: boolean + /** 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. */ + sinceSeconds?: number + /** 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 */ + tailLines?: number + /** If true, add an RFC3339 or RFC3339Nano timestamp at the beginning of every line of log output. Defaults to false. */ + timestamps?: boolean +} +export type ConnectCoreV1GetNamespacedPodPortforwardApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1GetNamespacedPodPortforwardApiArg = { + /** name of the PodPortForwardOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** List of ports to forward Required when using WebSockets */ + ports?: number +} +export type ConnectCoreV1PostNamespacedPodPortforwardApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PostNamespacedPodPortforwardApiArg = { + /** name of the PodPortForwardOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** List of ports to forward Required when using WebSockets */ + ports?: number +} +export type ConnectCoreV1GetNamespacedPodProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1GetNamespacedPodProxyApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** Path is the URL path to use for the current proxy request to pod. */ + path?: string +} +export type ConnectCoreV1PutNamespacedPodProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PutNamespacedPodProxyApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** Path is the URL path to use for the current proxy request to pod. */ + path?: string +} +export type ConnectCoreV1PostNamespacedPodProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PostNamespacedPodProxyApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** Path is the URL path to use for the current proxy request to pod. */ + path?: string +} +export type ConnectCoreV1DeleteNamespacedPodProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1DeleteNamespacedPodProxyApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** Path is the URL path to use for the current proxy request to pod. */ + path?: string +} +export type ConnectCoreV1OptionsNamespacedPodProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1OptionsNamespacedPodProxyApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** Path is the URL path to use for the current proxy request to pod. */ + path?: string +} +export type ConnectCoreV1HeadNamespacedPodProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1HeadNamespacedPodProxyApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** Path is the URL path to use for the current proxy request to pod. */ + path?: string +} +export type ConnectCoreV1PatchNamespacedPodProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PatchNamespacedPodProxyApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** Path is the URL path to use for the current proxy request to pod. */ + path?: string +} +export type ConnectCoreV1GetNamespacedPodProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1GetNamespacedPodProxyWithPathApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to pod. */ + queryPath?: string +} +export type ConnectCoreV1PutNamespacedPodProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PutNamespacedPodProxyWithPathApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to pod. */ + queryPath?: string +} +export type ConnectCoreV1PostNamespacedPodProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PostNamespacedPodProxyWithPathApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to pod. */ + queryPath?: string +} +export type ConnectCoreV1DeleteNamespacedPodProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1DeleteNamespacedPodProxyWithPathApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to pod. */ + queryPath?: string +} +export type ConnectCoreV1OptionsNamespacedPodProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1OptionsNamespacedPodProxyWithPathApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to pod. */ + queryPath?: string +} +export type ConnectCoreV1HeadNamespacedPodProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1HeadNamespacedPodProxyWithPathApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to pod. */ + queryPath?: string +} +export type ConnectCoreV1PatchNamespacedPodProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PatchNamespacedPodProxyWithPathApiArg = { + /** name of the PodProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to pod. */ + queryPath?: string +} +export type ReadCoreV1NamespacedPodStatusApiResponse = + /** status 200 OK */ IoK8SApiCoreV1Pod +export type ReadCoreV1NamespacedPodStatusApiArg = { + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedPodStatusApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Pod | /** status 201 Created */ IoK8SApiCoreV1Pod +export type ReplaceCoreV1NamespacedPodStatusApiArg = { + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Pod +} +export type PatchCoreV1NamespacedPodStatusApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Pod | /** status 201 Created */ IoK8SApiCoreV1Pod +export type PatchCoreV1NamespacedPodStatusApiArg = { + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Pod + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Pod + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Pod + } +) +export type ListCoreV1NamespacedPodTemplateApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PodTemplateList +export type ListCoreV1NamespacedPodTemplateApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedPodTemplateApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PodTemplate + | /** status 201 Created */ IoK8SApiCoreV1PodTemplate + | /** status 202 Accepted */ IoK8SApiCoreV1PodTemplate +export type CreateCoreV1NamespacedPodTemplateApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1PodTemplate +} +export type DeleteCoreV1CollectionNamespacedPodTemplateApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedPodTemplateApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedPodTemplateApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PodTemplate +export type ReadCoreV1NamespacedPodTemplateApiArg = { + /** name of the PodTemplate */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedPodTemplateApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PodTemplate + | /** status 201 Created */ IoK8SApiCoreV1PodTemplate +export type ReplaceCoreV1NamespacedPodTemplateApiArg = { + /** name of the PodTemplate */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1PodTemplate +} +export type DeleteCoreV1NamespacedPodTemplateApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PodTemplate + | /** status 202 Accepted */ IoK8SApiCoreV1PodTemplate +export type DeleteCoreV1NamespacedPodTemplateApiArg = { + /** name of the PodTemplate */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedPodTemplateApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PodTemplate + | /** status 201 Created */ IoK8SApiCoreV1PodTemplate +export type PatchCoreV1NamespacedPodTemplateApiArg = { + /** name of the PodTemplate */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1PodTemplate & { + apiVersion: 'v1' + kind: 'PodTemplate' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1PodTemplate + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1PodTemplate + } +) +export type ListCoreV1NamespacedReplicationControllerApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ReplicationControllerList +export type ListCoreV1NamespacedReplicationControllerApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedReplicationControllerApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ReplicationController + | /** status 201 Created */ IoK8SApiCoreV1ReplicationController + | /** status 202 Accepted */ IoK8SApiCoreV1ReplicationController +export type CreateCoreV1NamespacedReplicationControllerApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1ReplicationController +} +export type DeleteCoreV1CollectionNamespacedReplicationControllerApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedReplicationControllerApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedReplicationControllerApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ReplicationController +export type ReadCoreV1NamespacedReplicationControllerApiArg = { + /** name of the ReplicationController */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedReplicationControllerApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ReplicationController + | /** status 201 Created */ IoK8SApiCoreV1ReplicationController +export type ReplaceCoreV1NamespacedReplicationControllerApiArg = { + /** name of the ReplicationController */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1ReplicationController +} +export type DeleteCoreV1NamespacedReplicationControllerApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1NamespacedReplicationControllerApiArg = { + /** name of the ReplicationController */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedReplicationControllerApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ReplicationController + | /** status 201 Created */ IoK8SApiCoreV1ReplicationController +export type PatchCoreV1NamespacedReplicationControllerApiArg = { + /** name of the ReplicationController */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1ReplicationController & { + apiVersion: 'v1' + kind: 'ReplicationController' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1ReplicationController + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1ReplicationController + } +) +export type ReadCoreV1NamespacedReplicationControllerScaleApiResponse = + /** status 200 OK */ IoK8SApiAutoscalingV1Scale +export type ReadCoreV1NamespacedReplicationControllerScaleApiArg = { + /** name of the Scale */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedReplicationControllerScaleApiResponse = + /** status 200 OK */ + | IoK8SApiAutoscalingV1Scale + | /** status 201 Created */ IoK8SApiAutoscalingV1Scale +export type ReplaceCoreV1NamespacedReplicationControllerScaleApiArg = { + /** name of the Scale */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiAutoscalingV1Scale +} +export type PatchCoreV1NamespacedReplicationControllerScaleApiResponse = + /** status 200 OK */ + | IoK8SApiAutoscalingV1Scale + | /** status 201 Created */ IoK8SApiAutoscalingV1Scale +export type PatchCoreV1NamespacedReplicationControllerScaleApiArg = { + /** name of the Scale */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiAutoscalingV1Scale & { + apiVersion: 'v1/namespaces' + kind: 'Scale' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiAutoscalingV1Scale + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiAutoscalingV1Scale + } +) +export type ReadCoreV1NamespacedReplicationControllerStatusApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ReplicationController +export type ReadCoreV1NamespacedReplicationControllerStatusApiArg = { + /** name of the ReplicationController */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedReplicationControllerStatusApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ReplicationController + | /** status 201 Created */ IoK8SApiCoreV1ReplicationController +export type ReplaceCoreV1NamespacedReplicationControllerStatusApiArg = { + /** name of the ReplicationController */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1ReplicationController +} +export type PatchCoreV1NamespacedReplicationControllerStatusApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ReplicationController + | /** status 201 Created */ IoK8SApiCoreV1ReplicationController +export type PatchCoreV1NamespacedReplicationControllerStatusApiArg = { + /** name of the ReplicationController */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1ReplicationController + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1ReplicationController + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1ReplicationController + } +) +export type ListCoreV1NamespacedResourceQuotaApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ResourceQuotaList +export type ListCoreV1NamespacedResourceQuotaApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedResourceQuotaApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ResourceQuota + | /** status 201 Created */ IoK8SApiCoreV1ResourceQuota + | /** status 202 Accepted */ IoK8SApiCoreV1ResourceQuota +export type CreateCoreV1NamespacedResourceQuotaApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1ResourceQuota +} +export type DeleteCoreV1CollectionNamespacedResourceQuotaApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedResourceQuotaApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedResourceQuotaApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ResourceQuota +export type ReadCoreV1NamespacedResourceQuotaApiArg = { + /** name of the ResourceQuota */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedResourceQuotaApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ResourceQuota + | /** status 201 Created */ IoK8SApiCoreV1ResourceQuota +export type ReplaceCoreV1NamespacedResourceQuotaApiArg = { + /** name of the ResourceQuota */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1ResourceQuota +} +export type DeleteCoreV1NamespacedResourceQuotaApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ResourceQuota + | /** status 202 Accepted */ IoK8SApiCoreV1ResourceQuota +export type DeleteCoreV1NamespacedResourceQuotaApiArg = { + /** name of the ResourceQuota */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedResourceQuotaApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ResourceQuota + | /** status 201 Created */ IoK8SApiCoreV1ResourceQuota +export type PatchCoreV1NamespacedResourceQuotaApiArg = { + /** name of the ResourceQuota */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1ResourceQuota & { + apiVersion: 'v1' + kind: 'ResourceQuota' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1ResourceQuota + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1ResourceQuota + } +) +export type ReadCoreV1NamespacedResourceQuotaStatusApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ResourceQuota +export type ReadCoreV1NamespacedResourceQuotaStatusApiArg = { + /** name of the ResourceQuota */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedResourceQuotaStatusApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ResourceQuota + | /** status 201 Created */ IoK8SApiCoreV1ResourceQuota +export type ReplaceCoreV1NamespacedResourceQuotaStatusApiArg = { + /** name of the ResourceQuota */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1ResourceQuota +} +export type PatchCoreV1NamespacedResourceQuotaStatusApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ResourceQuota + | /** status 201 Created */ IoK8SApiCoreV1ResourceQuota +export type PatchCoreV1NamespacedResourceQuotaStatusApiArg = { + /** name of the ResourceQuota */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1ResourceQuota + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1ResourceQuota + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1ResourceQuota + } +) +export type ListCoreV1NamespacedSecretApiResponse = + /** status 200 OK */ IoK8SApiCoreV1SecretList +export type ListCoreV1NamespacedSecretApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedSecretApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1Secret + | /** status 201 Created */ IoK8SApiCoreV1Secret + | /** status 202 Accepted */ IoK8SApiCoreV1Secret +export type CreateCoreV1NamespacedSecretApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Secret +} +export type DeleteCoreV1CollectionNamespacedSecretApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedSecretApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedSecretApiResponse = + /** status 200 OK */ IoK8SApiCoreV1Secret +export type ReadCoreV1NamespacedSecretApiArg = { + /** name of the Secret */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedSecretApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Secret | /** status 201 Created */ IoK8SApiCoreV1Secret +export type ReplaceCoreV1NamespacedSecretApiArg = { + /** name of the Secret */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Secret +} +export type DeleteCoreV1NamespacedSecretApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1NamespacedSecretApiArg = { + /** name of the Secret */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedSecretApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Secret | /** status 201 Created */ IoK8SApiCoreV1Secret +export type PatchCoreV1NamespacedSecretApiArg = { + /** name of the Secret */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Secret & { + apiVersion: 'v1' + kind: 'Secret' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Secret + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Secret + } +) +export type ListCoreV1NamespacedServiceAccountApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ServiceAccountList +export type ListCoreV1NamespacedServiceAccountApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedServiceAccountApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ServiceAccount + | /** status 201 Created */ IoK8SApiCoreV1ServiceAccount + | /** status 202 Accepted */ IoK8SApiCoreV1ServiceAccount +export type CreateCoreV1NamespacedServiceAccountApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1ServiceAccount +} +export type DeleteCoreV1CollectionNamespacedServiceAccountApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedServiceAccountApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedServiceAccountApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ServiceAccount +export type ReadCoreV1NamespacedServiceAccountApiArg = { + /** name of the ServiceAccount */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedServiceAccountApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ServiceAccount + | /** status 201 Created */ IoK8SApiCoreV1ServiceAccount +export type ReplaceCoreV1NamespacedServiceAccountApiArg = { + /** name of the ServiceAccount */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1ServiceAccount +} +export type DeleteCoreV1NamespacedServiceAccountApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ServiceAccount + | /** status 202 Accepted */ IoK8SApiCoreV1ServiceAccount +export type DeleteCoreV1NamespacedServiceAccountApiArg = { + /** name of the ServiceAccount */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedServiceAccountApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1ServiceAccount + | /** status 201 Created */ IoK8SApiCoreV1ServiceAccount +export type PatchCoreV1NamespacedServiceAccountApiArg = { + /** name of the ServiceAccount */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1ServiceAccount & { + apiVersion: 'v1' + kind: 'ServiceAccount' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1ServiceAccount + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1ServiceAccount + } +) +export type CreateCoreV1NamespacedServiceAccountTokenApiResponse = + /** status 200 OK */ + | IoK8SApiAuthenticationV1TokenRequest + | /** status 201 Created */ IoK8SApiAuthenticationV1TokenRequest + | /** status 202 Accepted */ IoK8SApiAuthenticationV1TokenRequest +export type CreateCoreV1NamespacedServiceAccountTokenApiArg = { + /** When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** name of the TokenRequest */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} & { + contentType?: string + body: IoK8SApiAuthenticationV1TokenRequest +} +export type ListCoreV1NamespacedServiceApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ServiceList +export type ListCoreV1NamespacedServiceApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NamespacedServiceApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1Service + | /** status 201 Created */ IoK8SApiCoreV1Service + | /** status 202 Accepted */ IoK8SApiCoreV1Service +export type CreateCoreV1NamespacedServiceApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Service +} +export type DeleteCoreV1CollectionNamespacedServiceApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNamespacedServiceApiArg = { + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NamespacedServiceApiResponse = + /** status 200 OK */ IoK8SApiCoreV1Service +export type ReadCoreV1NamespacedServiceApiArg = { + /** name of the Service */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedServiceApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Service | /** status 201 Created */ IoK8SApiCoreV1Service +export type ReplaceCoreV1NamespacedServiceApiArg = { + /** name of the Service */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Service +} +export type DeleteCoreV1NamespacedServiceApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Service | /** status 202 Accepted */ IoK8SApiCoreV1Service +export type DeleteCoreV1NamespacedServiceApiArg = { + /** name of the Service */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespacedServiceApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Service | /** status 201 Created */ IoK8SApiCoreV1Service +export type PatchCoreV1NamespacedServiceApiArg = { + /** name of the Service */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Service & { + apiVersion: 'v1' + kind: 'Service' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Service + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Service + } +) +export type ConnectCoreV1GetNamespacedServiceProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1GetNamespacedServiceProxyApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** 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. */ + path?: string +} +export type ConnectCoreV1PutNamespacedServiceProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PutNamespacedServiceProxyApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** 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. */ + path?: string +} +export type ConnectCoreV1PostNamespacedServiceProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PostNamespacedServiceProxyApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** 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. */ + path?: string +} +export type ConnectCoreV1DeleteNamespacedServiceProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1DeleteNamespacedServiceProxyApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** 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. */ + path?: string +} +export type ConnectCoreV1OptionsNamespacedServiceProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1OptionsNamespacedServiceProxyApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** 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. */ + path?: string +} +export type ConnectCoreV1HeadNamespacedServiceProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1HeadNamespacedServiceProxyApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** 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. */ + path?: string +} +export type ConnectCoreV1PatchNamespacedServiceProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PatchNamespacedServiceProxyApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** 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. */ + path?: string +} +export type ConnectCoreV1GetNamespacedServiceProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1GetNamespacedServiceProxyWithPathApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** 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. */ + queryPath?: string +} +export type ConnectCoreV1PutNamespacedServiceProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PutNamespacedServiceProxyWithPathApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** 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. */ + queryPath?: string +} +export type ConnectCoreV1PostNamespacedServiceProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PostNamespacedServiceProxyWithPathApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** 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. */ + queryPath?: string +} +export type ConnectCoreV1DeleteNamespacedServiceProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1DeleteNamespacedServiceProxyWithPathApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** 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. */ + queryPath?: string +} +export type ConnectCoreV1OptionsNamespacedServiceProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1OptionsNamespacedServiceProxyWithPathApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** 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. */ + queryPath?: string +} +export type ConnectCoreV1HeadNamespacedServiceProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1HeadNamespacedServiceProxyWithPathApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** 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. */ + queryPath?: string +} +export type ConnectCoreV1PatchNamespacedServiceProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PatchNamespacedServiceProxyWithPathApiArg = { + /** name of the ServiceProxyOptions */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** path to the resource */ + pathPath: string + /** 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. */ + queryPath?: string +} +export type ReadCoreV1NamespacedServiceStatusApiResponse = + /** status 200 OK */ IoK8SApiCoreV1Service +export type ReadCoreV1NamespacedServiceStatusApiArg = { + /** name of the Service */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespacedServiceStatusApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Service | /** status 201 Created */ IoK8SApiCoreV1Service +export type ReplaceCoreV1NamespacedServiceStatusApiArg = { + /** name of the Service */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Service +} +export type PatchCoreV1NamespacedServiceStatusApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Service | /** status 201 Created */ IoK8SApiCoreV1Service +export type PatchCoreV1NamespacedServiceStatusApiArg = { + /** name of the Service */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Service + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Service + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Service + } +) +export type ReadCoreV1NamespaceApiResponse = + /** status 200 OK */ IoK8SApiCoreV1Namespace +export type ReadCoreV1NamespaceApiArg = { + /** name of the Namespace */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespaceApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Namespace | /** status 201 Created */ IoK8SApiCoreV1Namespace +export type ReplaceCoreV1NamespaceApiArg = { + /** name of the Namespace */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Namespace +} +export type DeleteCoreV1NamespaceApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1NamespaceApiArg = { + /** name of the Namespace */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NamespaceApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Namespace | /** status 201 Created */ IoK8SApiCoreV1Namespace +export type PatchCoreV1NamespaceApiArg = { + /** name of the Namespace */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Namespace & { + apiVersion: 'v1' + kind: 'Namespace' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Namespace + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Namespace + } +) +export type ReplaceCoreV1NamespaceFinalizeApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Namespace | /** status 201 Created */ IoK8SApiCoreV1Namespace +export type ReplaceCoreV1NamespaceFinalizeApiArg = { + /** When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** name of the Namespace */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Namespace +} +export type ReadCoreV1NamespaceStatusApiResponse = + /** status 200 OK */ IoK8SApiCoreV1Namespace +export type ReadCoreV1NamespaceStatusApiArg = { + /** name of the Namespace */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NamespaceStatusApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Namespace | /** status 201 Created */ IoK8SApiCoreV1Namespace +export type ReplaceCoreV1NamespaceStatusApiArg = { + /** name of the Namespace */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Namespace +} +export type PatchCoreV1NamespaceStatusApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Namespace | /** status 201 Created */ IoK8SApiCoreV1Namespace +export type PatchCoreV1NamespaceStatusApiArg = { + /** name of the Namespace */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Namespace + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Namespace + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Namespace + } +) +export type ListCoreV1NodeApiResponse = + /** status 200 OK */ IoK8SApiCoreV1NodeList +export type ListCoreV1NodeApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1NodeApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1Node + | /** status 201 Created */ IoK8SApiCoreV1Node + | /** status 202 Accepted */ IoK8SApiCoreV1Node +export type CreateCoreV1NodeApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Node +} +export type DeleteCoreV1CollectionNodeApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionNodeApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1NodeApiResponse = /** status 200 OK */ IoK8SApiCoreV1Node +export type ReadCoreV1NodeApiArg = { + /** name of the Node */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NodeApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Node | /** status 201 Created */ IoK8SApiCoreV1Node +export type ReplaceCoreV1NodeApiArg = { + /** name of the Node */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Node +} +export type DeleteCoreV1NodeApiResponse = + /** status 200 OK */ + | IoK8SApimachineryPkgApisMetaV1Status + | /** status 202 Accepted */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1NodeApiArg = { + /** name of the Node */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1NodeApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Node | /** status 201 Created */ IoK8SApiCoreV1Node +export type PatchCoreV1NodeApiArg = { + /** name of the Node */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Node & { + apiVersion: 'v1' + kind: 'Node' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Node + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Node + } +) +export type ConnectCoreV1GetNodeProxyApiResponse = /** status 200 OK */ string +export type ConnectCoreV1GetNodeProxyApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** Path is the URL path to use for the current proxy request to node. */ + path?: string +} +export type ConnectCoreV1PutNodeProxyApiResponse = /** status 200 OK */ string +export type ConnectCoreV1PutNodeProxyApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** Path is the URL path to use for the current proxy request to node. */ + path?: string +} +export type ConnectCoreV1PostNodeProxyApiResponse = /** status 200 OK */ string +export type ConnectCoreV1PostNodeProxyApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** Path is the URL path to use for the current proxy request to node. */ + path?: string +} +export type ConnectCoreV1DeleteNodeProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1DeleteNodeProxyApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** Path is the URL path to use for the current proxy request to node. */ + path?: string +} +export type ConnectCoreV1OptionsNodeProxyApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1OptionsNodeProxyApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** Path is the URL path to use for the current proxy request to node. */ + path?: string +} +export type ConnectCoreV1HeadNodeProxyApiResponse = /** status 200 OK */ string +export type ConnectCoreV1HeadNodeProxyApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** Path is the URL path to use for the current proxy request to node. */ + path?: string +} +export type ConnectCoreV1PatchNodeProxyApiResponse = /** status 200 OK */ string +export type ConnectCoreV1PatchNodeProxyApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** Path is the URL path to use for the current proxy request to node. */ + path?: string +} +export type ConnectCoreV1GetNodeProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1GetNodeProxyWithPathApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to node. */ + queryPath?: string +} +export type ConnectCoreV1PutNodeProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PutNodeProxyWithPathApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to node. */ + queryPath?: string +} +export type ConnectCoreV1PostNodeProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PostNodeProxyWithPathApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to node. */ + queryPath?: string +} +export type ConnectCoreV1DeleteNodeProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1DeleteNodeProxyWithPathApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to node. */ + queryPath?: string +} +export type ConnectCoreV1OptionsNodeProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1OptionsNodeProxyWithPathApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to node. */ + queryPath?: string +} +export type ConnectCoreV1HeadNodeProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1HeadNodeProxyWithPathApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to node. */ + queryPath?: string +} +export type ConnectCoreV1PatchNodeProxyWithPathApiResponse = + /** status 200 OK */ string +export type ConnectCoreV1PatchNodeProxyWithPathApiArg = { + /** name of the NodeProxyOptions */ + name: string + /** path to the resource */ + pathPath: string + /** Path is the URL path to use for the current proxy request to node. */ + queryPath?: string +} +export type ReadCoreV1NodeStatusApiResponse = + /** status 200 OK */ IoK8SApiCoreV1Node +export type ReadCoreV1NodeStatusApiArg = { + /** name of the Node */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1NodeStatusApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Node | /** status 201 Created */ IoK8SApiCoreV1Node +export type ReplaceCoreV1NodeStatusApiArg = { + /** name of the Node */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1Node +} +export type PatchCoreV1NodeStatusApiResponse = + /** status 200 OK */ + IoK8SApiCoreV1Node | /** status 201 Created */ IoK8SApiCoreV1Node +export type PatchCoreV1NodeStatusApiArg = { + /** name of the Node */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1Node + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1Node + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1Node + } +) +export type ListCoreV1PersistentVolumeClaimForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PersistentVolumeClaimList +export type ListCoreV1PersistentVolumeClaimForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListCoreV1PersistentVolumeApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PersistentVolumeList +export type ListCoreV1PersistentVolumeApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type CreateCoreV1PersistentVolumeApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolume + | /** status 201 Created */ IoK8SApiCoreV1PersistentVolume + | /** status 202 Accepted */ IoK8SApiCoreV1PersistentVolume +export type CreateCoreV1PersistentVolumeApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1PersistentVolume +} +export type DeleteCoreV1CollectionPersistentVolumeApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1Status +export type DeleteCoreV1CollectionPersistentVolumeApiArg = { + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: 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 */ + dryRun?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type ReadCoreV1PersistentVolumeApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PersistentVolume +export type ReadCoreV1PersistentVolumeApiArg = { + /** name of the PersistentVolume */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1PersistentVolumeApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolume + | /** status 201 Created */ IoK8SApiCoreV1PersistentVolume +export type ReplaceCoreV1PersistentVolumeApiArg = { + /** name of the PersistentVolume */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1PersistentVolume +} +export type DeleteCoreV1PersistentVolumeApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolume + | /** status 202 Accepted */ IoK8SApiCoreV1PersistentVolume +export type DeleteCoreV1PersistentVolumeApiArg = { + /** name of the PersistentVolume */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately. */ + gracePeriodSeconds?: number + /** Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both. */ + orphanDependents?: boolean + /** Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground. */ + propagationPolicy?: string +} & { + contentType?: string + body: IoK8SApimachineryPkgApisMetaV1DeleteOptions +} +export type PatchCoreV1PersistentVolumeApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolume + | /** status 201 Created */ IoK8SApiCoreV1PersistentVolume +export type PatchCoreV1PersistentVolumeApiArg = { + /** name of the PersistentVolume */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1PersistentVolume & { + apiVersion: 'v1' + kind: 'PersistentVolume' + } + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1PersistentVolume + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1PersistentVolume + } +) +export type ReadCoreV1PersistentVolumeStatusApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PersistentVolume +export type ReadCoreV1PersistentVolumeStatusApiArg = { + /** name of the PersistentVolume */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string +} +export type ReplaceCoreV1PersistentVolumeStatusApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolume + | /** status 201 Created */ IoK8SApiCoreV1PersistentVolume +export type ReplaceCoreV1PersistentVolumeStatusApiArg = { + /** name of the PersistentVolume */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string +} & { + contentType?: string + body: IoK8SApiCoreV1PersistentVolume +} +export type PatchCoreV1PersistentVolumeStatusApiResponse = + /** status 200 OK */ + | IoK8SApiCoreV1PersistentVolume + | /** status 201 Created */ IoK8SApiCoreV1PersistentVolume +export type PatchCoreV1PersistentVolumeStatusApiArg = { + /** name of the PersistentVolume */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: 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 */ + dryRun?: string + /** fieldManager is a name associated with the actor or entity that is making these changes. 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). */ + fieldManager?: string + /** fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered. */ + fieldValidation?: string + /** 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. */ + force?: boolean +} & ( + | { + contentType: 'application/apply-patch+yaml' + body: IoK8SApiCoreV1PersistentVolume + } + | { + contentType: 'application/json-patch+json' + body: JsonPatchOperations + } + | { + contentType: 'application/merge-patch+json' + body: IoK8SApiCoreV1PersistentVolume + } + | { + contentType: 'application/strategic-merge-patch+json' + body: IoK8SApiCoreV1PersistentVolume + } +) +export type ListCoreV1PodForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PodList +export type ListCoreV1PodForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListCoreV1PodTemplateForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1PodTemplateList +export type ListCoreV1PodTemplateForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListCoreV1ReplicationControllerForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ReplicationControllerList +export type ListCoreV1ReplicationControllerForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListCoreV1ResourceQuotaForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ResourceQuotaList +export type ListCoreV1ResourceQuotaForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListCoreV1SecretForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1SecretList +export type ListCoreV1SecretForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListCoreV1ServiceAccountForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ServiceAccountList +export type ListCoreV1ServiceAccountForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type ListCoreV1ServiceForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApiCoreV1ServiceList +export type ListCoreV1ServiceForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1ConfigMapListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1ConfigMapListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1EndpointsListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1EndpointsListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1EventListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1EventListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1LimitRangeListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1LimitRangeListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespaceListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespaceListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedConfigMapListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedConfigMapListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedConfigMapApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedConfigMapApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the ConfigMap */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedEndpointsListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedEndpointsListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedEndpointsApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedEndpointsApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the Endpoints */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedEventListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedEventListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedEventApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedEventApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the Event */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedLimitRangeListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedLimitRangeListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedLimitRangeApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedLimitRangeApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the LimitRange */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedPersistentVolumeClaimListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedPersistentVolumeClaimListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedPersistentVolumeClaimApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedPersistentVolumeClaimApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the PersistentVolumeClaim */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedPodListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedPodListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedPodApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedPodApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the Pod */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedPodTemplateListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedPodTemplateListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedPodTemplateApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedPodTemplateApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the PodTemplate */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedReplicationControllerListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedReplicationControllerListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedReplicationControllerApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedReplicationControllerApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the ReplicationController */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedResourceQuotaListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedResourceQuotaListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedResourceQuotaApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedResourceQuotaApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the ResourceQuota */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedSecretListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedSecretListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedSecretApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedSecretApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the Secret */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedServiceAccountListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedServiceAccountListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedServiceAccountApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedServiceAccountApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the ServiceAccount */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedServiceListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedServiceListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespacedServiceApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespacedServiceApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the Service */ + name: string + /** object name and auth scope, such as for teams and projects */ + namespace: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NamespaceApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NamespaceApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the Namespace */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NodeListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NodeListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1NodeApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1NodeApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the Node */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1PersistentVolumeClaimListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1PersistentVolumeClaimListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1PersistentVolumeListApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1PersistentVolumeListApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1PersistentVolumeApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1PersistentVolumeApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** name of the PersistentVolume */ + name: string + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1PodListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1PodListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1PodTemplateListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1PodTemplateListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1ReplicationControllerListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1ReplicationControllerListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1ResourceQuotaListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1ResourceQuotaListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1SecretListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1SecretListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1ServiceAccountListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1ServiceAccountListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type WatchCoreV1ServiceListForAllNamespacesApiResponse = + /** status 200 OK */ IoK8SApimachineryPkgApisMetaV1WatchEvent +export type WatchCoreV1ServiceListForAllNamespacesApiArg = { + /** allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. */ + allowWatchBookmarks?: boolean + /** The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key". + + This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. */ + continue?: string + /** A selector to restrict the list of returned objects by their fields. Defaults to everything. */ + fieldSelector?: string + /** A selector to restrict the list of returned objects by their labels. Defaults to everything. */ + labelSelector?: string + /** limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. + + The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned. */ + limit?: number + /** If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). */ + pretty?: string + /** resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersion?: string + /** resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details. + + Defaults to unset */ + resourceVersionMatch?: string + /** `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic "Bookmark" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `"k8s.io/initial-events-end": "true"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. + + When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan + is interpreted as "data at least as new as the provided `resourceVersion`" + and the bookmark event is send when the state is synced + to a `resourceVersion` at least as fresh as the one provided by the ListOptions. + If `resourceVersion` is unset, this is interpreted as "consistent read" and the + bookmark event is send when the state is synced at least to the moment + when request started being processed. + - `resourceVersionMatch` set to any other value or unset + Invalid error is returned. + + Defaults to true if `resourceVersion=""` or `resourceVersion="0"` (for backward compatibility reasons) and to false otherwise. */ + sendInitialEvents?: boolean + /** Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity. */ + timeoutSeconds?: number + /** Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion. */ + watch?: boolean +} +export type IoK8SApimachineryPkgApisMetaV1ApiResource = { + categories?: string[] | undefined + group?: string | undefined + kind: string + name: string + namespaced: boolean + shortNames?: string[] | undefined + singularName: string + storageVersionHash?: string | undefined + verbs: string[] + version?: string | undefined +} +export type IoK8SApimachineryPkgApisMetaV1ApiResourceList = { + apiVersion?: string | undefined + groupVersion: string + kind?: string | undefined + resources: IoK8SApimachineryPkgApisMetaV1ApiResource[] +} +export type IoK8SApiCoreV1ComponentCondition = { + error?: string | undefined + message?: string | undefined + status: string + type: string +} +export type IoK8SApimachineryPkgApisMetaV1Time = string +export type IoK8SApimachineryPkgApisMetaV1FieldsV1 = object +export type IoK8SApimachineryPkgApisMetaV1ManagedFieldsEntry = { + apiVersion?: string | undefined + fieldsType?: string | undefined + fieldsV1?: IoK8SApimachineryPkgApisMetaV1FieldsV1 | undefined + manager?: string | undefined + operation?: string | undefined + subresource?: string | undefined + time?: IoK8SApimachineryPkgApisMetaV1Time | undefined +} +export type IoK8SApimachineryPkgApisMetaV1OwnerReference = { + apiVersion: string + blockOwnerDeletion?: boolean | undefined + controller?: boolean | undefined + kind: string + name: string + uid: string +} +export type IoK8SApimachineryPkgApisMetaV1ObjectMeta = { + annotations?: + | { + [key: string]: string + } + | undefined + creationTimestamp?: IoK8SApimachineryPkgApisMetaV1Time | undefined + deletionGracePeriodSeconds?: number | undefined + deletionTimestamp?: IoK8SApimachineryPkgApisMetaV1Time | undefined + finalizers?: string[] | undefined + generateName?: string | undefined + generation?: number | undefined + labels?: + | { + [key: string]: string + } + | undefined + managedFields?: IoK8SApimachineryPkgApisMetaV1ManagedFieldsEntry[] | undefined + name?: string | undefined + namespace?: string | undefined + ownerReferences?: IoK8SApimachineryPkgApisMetaV1OwnerReference[] | undefined + resourceVersion?: string | undefined + selfLink?: string | undefined + uid?: string | undefined +} +export type IoK8SApiCoreV1ComponentStatus = { + apiVersion?: 'v1' | undefined + conditions?: IoK8SApiCoreV1ComponentCondition[] | undefined + kind?: 'ComponentStatus' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined +} +export type IoK8SApimachineryPkgApisMetaV1ListMeta = { + continue?: string | undefined + remainingItemCount?: number | undefined + resourceVersion?: string | undefined + selfLink?: string | undefined +} +export type IoK8SApiCoreV1ComponentStatusList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1ComponentStatus[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiCoreV1ConfigMap = { + apiVersion?: 'v1' | undefined + binaryData?: + | { + [key: string]: string + } + | undefined + data?: + | { + [key: string]: string + } + | undefined + immutable?: boolean | undefined + kind?: 'ConfigMap' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined +} +export type IoK8SApiCoreV1ConfigMapList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1ConfigMap[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiCoreV1ObjectReference = { + apiVersion?: string | undefined + fieldPath?: string | undefined + kind?: string | undefined + name?: string | undefined + namespace?: string | undefined + resourceVersion?: string | undefined + uid?: string | undefined +} +export type IoK8SApiCoreV1EndpointAddress = { + hostname?: string | undefined + ip: string + nodeName?: string | undefined + targetRef?: IoK8SApiCoreV1ObjectReference | undefined +} +export type IoK8SApiCoreV1EndpointPort = { + appProtocol?: string | undefined + name?: string | undefined + port: number + protocol?: ('SCTP' | 'TCP' | 'UDP') | undefined +} +export type IoK8SApiCoreV1EndpointSubset = { + addresses?: IoK8SApiCoreV1EndpointAddress[] | undefined + notReadyAddresses?: IoK8SApiCoreV1EndpointAddress[] | undefined + ports?: IoK8SApiCoreV1EndpointPort[] | undefined +} +export type IoK8SApiCoreV1Endpoints = { + apiVersion?: 'v1' | undefined + kind?: 'Endpoints' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + subsets?: IoK8SApiCoreV1EndpointSubset[] | undefined +} +export type IoK8SApiCoreV1EndpointsList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1Endpoints[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApimachineryPkgApisMetaV1MicroTime = string +export type IoK8SApiCoreV1EventSeries = { + count?: number | undefined + lastObservedTime?: IoK8SApimachineryPkgApisMetaV1MicroTime | undefined +} +export type IoK8SApiCoreV1EventSource = { + component?: string | undefined + host?: string | undefined +} +export type IoK8SApiCoreV1Event = { + action?: string | undefined + apiVersion?: 'v1' | undefined + count?: number | undefined + eventTime?: IoK8SApimachineryPkgApisMetaV1MicroTime | undefined + firstTimestamp?: IoK8SApimachineryPkgApisMetaV1Time | undefined + involvedObject: IoK8SApiCoreV1ObjectReference + kind?: 'Event' | undefined + lastTimestamp?: IoK8SApimachineryPkgApisMetaV1Time | undefined + message?: string | undefined + metadata: IoK8SApimachineryPkgApisMetaV1ObjectMeta + reason?: string | undefined + related?: IoK8SApiCoreV1ObjectReference | undefined + reportingComponent?: string | undefined + reportingInstance?: string | undefined + series?: IoK8SApiCoreV1EventSeries | undefined + source?: IoK8SApiCoreV1EventSource | undefined + type?: string | undefined +} +export type IoK8SApiCoreV1EventList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1Event[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApimachineryPkgApiResourceQuantity = string | number +export type IoK8SApiCoreV1LimitRangeItem = { + default?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + defaultRequest?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + max?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + maxLimitRequestRatio?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + min?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + type: string +} +export type IoK8SApiCoreV1LimitRangeSpec = { + limits: IoK8SApiCoreV1LimitRangeItem[] +} +export type IoK8SApiCoreV1LimitRange = { + apiVersion?: 'v1' | undefined + kind?: 'LimitRange' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec?: IoK8SApiCoreV1LimitRangeSpec | undefined +} +export type IoK8SApiCoreV1LimitRangeList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1LimitRange[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiCoreV1NamespaceSpec = { + finalizers?: string[] | undefined +} +export type IoK8SApiCoreV1NamespaceCondition = { + lastTransitionTime?: IoK8SApimachineryPkgApisMetaV1Time | undefined + message?: string | undefined + reason?: string | undefined + status: string + type: string +} +export type IoK8SApiCoreV1NamespaceStatus = { + conditions?: IoK8SApiCoreV1NamespaceCondition[] | undefined + phase?: ('Active' | 'Terminating') | undefined +} +export type IoK8SApiCoreV1Namespace = { + apiVersion?: 'v1' | undefined + kind?: 'Namespace' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec?: IoK8SApiCoreV1NamespaceSpec | undefined + status?: IoK8SApiCoreV1NamespaceStatus | undefined +} +export type IoK8SApiCoreV1NamespaceList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1Namespace[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiCoreV1Binding = { + apiVersion?: 'v1' | undefined + kind?: 'Binding' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + target: IoK8SApiCoreV1ObjectReference +} +export type IoK8SApimachineryPkgApisMetaV1StatusCause = { + field?: string | undefined + message?: string | undefined + reason?: string | undefined +} +export type IoK8SApimachineryPkgApisMetaV1StatusDetails = { + causes?: IoK8SApimachineryPkgApisMetaV1StatusCause[] | undefined + group?: string | undefined + kind?: string | undefined + name?: string | undefined + retryAfterSeconds?: number | undefined + uid?: string | undefined +} +export type IoK8SApimachineryPkgApisMetaV1Status = { + apiVersion?: 'k8s.apimachinery.pkg.apis.meta.io/v1' | undefined + code?: number | undefined + details?: IoK8SApimachineryPkgApisMetaV1StatusDetails | undefined + kind?: 'Status' | undefined + message?: string | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ListMeta | undefined + reason?: string | undefined + status?: string | undefined +} +export type IoK8SApimachineryPkgApisMetaV1Preconditions = { + resourceVersion?: string | undefined + uid?: string | undefined +} +export type IoK8SApimachineryPkgApisMetaV1DeleteOptions = { + apiVersion?: string | undefined + dryRun?: string[] | undefined + gracePeriodSeconds?: number | undefined + kind?: string | undefined + orphanDependents?: boolean | undefined + preconditions?: IoK8SApimachineryPkgApisMetaV1Preconditions | undefined + propagationPolicy?: string | undefined +} +export type AddOperation = { + op: 'add' + path: string + value: string | number | boolean | any | object +} +export type RemoveOperation = { + op: 'remove' + path: string +} +export type ReplaceOperation = { + op: 'replace' + path: string + value: string | number | boolean | any | object +} +export type MoveOperation = { + op: 'move' + path: string + from: string +} +export type CopyOperation = { + op: 'copy' + path: string + from: string +} +export type TestOperation = { + op: 'test' + path: string + value: string | number | boolean | any | object +} +export type JsonPatchOperation = + | AddOperation + | RemoveOperation + | ReplaceOperation + | MoveOperation + | CopyOperation + | TestOperation +export type JsonPatchOperations = JsonPatchOperation[] +export type IoK8SApiCoreV1TypedLocalObjectReference = { + apiGroup?: string | undefined + kind: string + name: string +} +export type IoK8SApiCoreV1TypedObjectReference = { + apiGroup?: string | undefined + kind: string + name: string + namespace?: string | undefined +} +export type IoK8SApiCoreV1VolumeResourceRequirements = { + limits?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + requests?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined +} +export type IoK8SApimachineryPkgApisMetaV1LabelSelectorRequirement = { + key: string + operator: string + values?: string[] | undefined +} +export type IoK8SApimachineryPkgApisMetaV1LabelSelector = { + matchExpressions?: + | IoK8SApimachineryPkgApisMetaV1LabelSelectorRequirement[] + | undefined + matchLabels?: + | { + [key: string]: string + } + | undefined +} +export type IoK8SApiCoreV1PersistentVolumeClaimSpec = { + accessModes?: string[] | undefined + dataSource?: IoK8SApiCoreV1TypedLocalObjectReference | undefined + dataSourceRef?: IoK8SApiCoreV1TypedObjectReference | undefined + resources?: IoK8SApiCoreV1VolumeResourceRequirements | undefined + selector?: IoK8SApimachineryPkgApisMetaV1LabelSelector | undefined + storageClassName?: string | undefined + volumeAttributesClassName?: string | undefined + volumeMode?: ('Block' | 'Filesystem') | undefined + volumeName?: string | undefined +} +export type IoK8SApiCoreV1PersistentVolumeClaimCondition = { + lastProbeTime?: IoK8SApimachineryPkgApisMetaV1Time | undefined + lastTransitionTime?: IoK8SApimachineryPkgApisMetaV1Time | undefined + message?: string | undefined + reason?: string | undefined + status: string + type: string +} +export type IoK8SApiCoreV1ModifyVolumeStatus = { + status: 'InProgress' | 'Infeasible' | 'Pending' + targetVolumeAttributesClassName?: string | undefined +} +export type IoK8SApiCoreV1PersistentVolumeClaimStatus = { + accessModes?: string[] | undefined + allocatedResourceStatuses?: + | { + [key: string]: string + } + | undefined + allocatedResources?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + capacity?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + conditions?: IoK8SApiCoreV1PersistentVolumeClaimCondition[] | undefined + currentVolumeAttributesClassName?: string | undefined + modifyVolumeStatus?: IoK8SApiCoreV1ModifyVolumeStatus | undefined + phase?: ('Bound' | 'Lost' | 'Pending') | undefined +} +export type IoK8SApiCoreV1PersistentVolumeClaim = { + apiVersion?: 'v1' | undefined + kind?: 'PersistentVolumeClaim' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec?: IoK8SApiCoreV1PersistentVolumeClaimSpec | undefined + status?: IoK8SApiCoreV1PersistentVolumeClaimStatus | undefined +} +export type IoK8SApiCoreV1PersistentVolumeClaimList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1PersistentVolumeClaim[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiCoreV1NodeSelectorRequirement = { + key: string + operator: 'DoesNotExist' | 'Exists' | 'Gt' | 'In' | 'Lt' | 'NotIn' + values?: string[] | undefined +} +export type IoK8SApiCoreV1NodeSelectorTerm = { + matchExpressions?: IoK8SApiCoreV1NodeSelectorRequirement[] | undefined + matchFields?: IoK8SApiCoreV1NodeSelectorRequirement[] | undefined +} +export type IoK8SApiCoreV1PreferredSchedulingTerm = { + preference: IoK8SApiCoreV1NodeSelectorTerm + weight: number +} +export type IoK8SApiCoreV1NodeSelector = { + nodeSelectorTerms: IoK8SApiCoreV1NodeSelectorTerm[] +} +export type IoK8SApiCoreV1NodeAffinity = { + preferredDuringSchedulingIgnoredDuringExecution?: + | IoK8SApiCoreV1PreferredSchedulingTerm[] + | undefined + requiredDuringSchedulingIgnoredDuringExecution?: + | IoK8SApiCoreV1NodeSelector + | undefined +} +export type IoK8SApiCoreV1PodAffinityTerm = { + labelSelector?: IoK8SApimachineryPkgApisMetaV1LabelSelector | undefined + matchLabelKeys?: string[] | undefined + mismatchLabelKeys?: string[] | undefined + namespaceSelector?: IoK8SApimachineryPkgApisMetaV1LabelSelector | undefined + namespaces?: string[] | undefined + topologyKey: string +} +export type IoK8SApiCoreV1WeightedPodAffinityTerm = { + podAffinityTerm: IoK8SApiCoreV1PodAffinityTerm + weight: number +} +export type IoK8SApiCoreV1PodAffinity = { + preferredDuringSchedulingIgnoredDuringExecution?: + | IoK8SApiCoreV1WeightedPodAffinityTerm[] + | undefined + requiredDuringSchedulingIgnoredDuringExecution?: + | IoK8SApiCoreV1PodAffinityTerm[] + | undefined +} +export type IoK8SApiCoreV1PodAntiAffinity = { + preferredDuringSchedulingIgnoredDuringExecution?: + | IoK8SApiCoreV1WeightedPodAffinityTerm[] + | undefined + requiredDuringSchedulingIgnoredDuringExecution?: + | IoK8SApiCoreV1PodAffinityTerm[] + | undefined +} +export type IoK8SApiCoreV1Affinity = { + nodeAffinity?: IoK8SApiCoreV1NodeAffinity | undefined + podAffinity?: IoK8SApiCoreV1PodAffinity | undefined + podAntiAffinity?: IoK8SApiCoreV1PodAntiAffinity | undefined +} +export type IoK8SApiCoreV1ConfigMapKeySelector = { + key: string + name?: string | undefined + optional?: boolean | undefined +} +export type IoK8SApiCoreV1ObjectFieldSelector = { + apiVersion?: string | undefined + fieldPath: string +} +export type IoK8SApiCoreV1ResourceFieldSelector = { + containerName?: string | undefined + divisor?: IoK8SApimachineryPkgApiResourceQuantity | undefined + resource: string +} +export type IoK8SApiCoreV1SecretKeySelector = { + key: string + name?: string | undefined + optional?: boolean | undefined +} +export type IoK8SApiCoreV1EnvVarSource = { + configMapKeyRef?: IoK8SApiCoreV1ConfigMapKeySelector | undefined + fieldRef?: IoK8SApiCoreV1ObjectFieldSelector | undefined + resourceFieldRef?: IoK8SApiCoreV1ResourceFieldSelector | undefined + secretKeyRef?: IoK8SApiCoreV1SecretKeySelector | undefined +} +export type IoK8SApiCoreV1EnvVar = { + name: string + value?: string | undefined + valueFrom?: IoK8SApiCoreV1EnvVarSource | undefined +} +export type IoK8SApiCoreV1ConfigMapEnvSource = { + name?: string | undefined + optional?: boolean | undefined +} +export type IoK8SApiCoreV1SecretEnvSource = { + name?: string | undefined + optional?: boolean | undefined +} +export type IoK8SApiCoreV1EnvFromSource = { + configMapRef?: IoK8SApiCoreV1ConfigMapEnvSource | undefined + prefix?: string | undefined + secretRef?: IoK8SApiCoreV1SecretEnvSource | undefined +} +export type IoK8SApiCoreV1ExecAction = { + command?: string[] | undefined +} +export type IoK8SApiCoreV1HttpHeader = { + name: string + value: string +} +export type IoK8SApimachineryPkgUtilIntstrIntOrString = number | string +export type IoK8SApiCoreV1HttpGetAction = { + host?: string | undefined + httpHeaders?: IoK8SApiCoreV1HttpHeader[] | undefined + path?: string | undefined + port: IoK8SApimachineryPkgUtilIntstrIntOrString + scheme?: ('HTTP' | 'HTTPS') | undefined +} +export type IoK8SApiCoreV1SleepAction = { + seconds: number +} +export type IoK8SApiCoreV1TcpSocketAction = { + host?: string | undefined + port: IoK8SApimachineryPkgUtilIntstrIntOrString +} +export type IoK8SApiCoreV1LifecycleHandler = { + exec?: IoK8SApiCoreV1ExecAction | undefined + httpGet?: IoK8SApiCoreV1HttpGetAction | undefined + sleep?: IoK8SApiCoreV1SleepAction | undefined + tcpSocket?: IoK8SApiCoreV1TcpSocketAction | undefined +} +export type IoK8SApiCoreV1Lifecycle = { + postStart?: IoK8SApiCoreV1LifecycleHandler | undefined + preStop?: IoK8SApiCoreV1LifecycleHandler | undefined +} +export type IoK8SApiCoreV1GrpcAction = { + port: number + service?: string | undefined +} +export type IoK8SApiCoreV1Probe = { + exec?: IoK8SApiCoreV1ExecAction | undefined + failureThreshold?: number | undefined + grpc?: IoK8SApiCoreV1GrpcAction | undefined + httpGet?: IoK8SApiCoreV1HttpGetAction | undefined + initialDelaySeconds?: number | undefined + periodSeconds?: number | undefined + successThreshold?: number | undefined + tcpSocket?: IoK8SApiCoreV1TcpSocketAction | undefined + terminationGracePeriodSeconds?: number | undefined + timeoutSeconds?: number | undefined +} +export type IoK8SApiCoreV1ContainerPort = { + containerPort: number + hostIP?: string | undefined + hostPort?: number | undefined + name?: string | undefined + protocol?: ('SCTP' | 'TCP' | 'UDP') | undefined +} +export type IoK8SApiCoreV1ContainerResizePolicy = { + resourceName: string + restartPolicy: string +} +export type IoK8SApiCoreV1ResourceClaim = { + name: string +} +export type IoK8SApiCoreV1ResourceRequirements = { + claims?: IoK8SApiCoreV1ResourceClaim[] | undefined + limits?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + requests?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined +} +export type IoK8SApiCoreV1Capabilities = { + add?: string[] | undefined + drop?: string[] | undefined +} +export type IoK8SApiCoreV1SeLinuxOptions = { + level?: string | undefined + role?: string | undefined + type?: string | undefined + user?: string | undefined +} +export type IoK8SApiCoreV1SeccompProfile = { + localhostProfile?: string | undefined + type: 'Localhost' | 'RuntimeDefault' | 'Unconfined' +} +export type IoK8SApiCoreV1WindowsSecurityContextOptions = { + gmsaCredentialSpec?: string | undefined + gmsaCredentialSpecName?: string | undefined + hostProcess?: boolean | undefined + runAsUserName?: string | undefined +} +export type IoK8SApiCoreV1SecurityContext = { + allowPrivilegeEscalation?: boolean | undefined + capabilities?: IoK8SApiCoreV1Capabilities | undefined + privileged?: boolean | undefined + procMount?: ('Default' | 'Unmasked') | undefined + readOnlyRootFilesystem?: boolean | undefined + runAsGroup?: number | undefined + runAsNonRoot?: boolean | undefined + runAsUser?: number | undefined + seLinuxOptions?: IoK8SApiCoreV1SeLinuxOptions | undefined + seccompProfile?: IoK8SApiCoreV1SeccompProfile | undefined + windowsOptions?: IoK8SApiCoreV1WindowsSecurityContextOptions | undefined +} +export type IoK8SApiCoreV1VolumeDevice = { + devicePath: string + name: string +} +export type IoK8SApiCoreV1VolumeMount = { + mountPath: string + mountPropagation?: ('Bidirectional' | 'HostToContainer' | 'None') | undefined + name: string + readOnly?: boolean | undefined + subPath?: string | undefined + subPathExpr?: string | undefined +} +export type IoK8SApiCoreV1Container = { + args?: string[] | undefined + command?: string[] | undefined + env?: IoK8SApiCoreV1EnvVar[] | undefined + envFrom?: IoK8SApiCoreV1EnvFromSource[] | undefined + image?: string | undefined + imagePullPolicy?: ('Always' | 'IfNotPresent' | 'Never') | undefined + lifecycle?: IoK8SApiCoreV1Lifecycle | undefined + livenessProbe?: IoK8SApiCoreV1Probe | undefined + name: string + ports?: IoK8SApiCoreV1ContainerPort[] | undefined + readinessProbe?: IoK8SApiCoreV1Probe | undefined + resizePolicy?: IoK8SApiCoreV1ContainerResizePolicy[] | undefined + resources?: IoK8SApiCoreV1ResourceRequirements | undefined + restartPolicy?: string | undefined + securityContext?: IoK8SApiCoreV1SecurityContext | undefined + startupProbe?: IoK8SApiCoreV1Probe | undefined + stdin?: boolean | undefined + stdinOnce?: boolean | undefined + terminationMessagePath?: string | undefined + terminationMessagePolicy?: ('FallbackToLogsOnError' | 'File') | undefined + tty?: boolean | undefined + volumeDevices?: IoK8SApiCoreV1VolumeDevice[] | undefined + volumeMounts?: IoK8SApiCoreV1VolumeMount[] | undefined + workingDir?: string | undefined +} +export type IoK8SApiCoreV1PodDnsConfigOption = { + name?: string | undefined + value?: string | undefined +} +export type IoK8SApiCoreV1PodDnsConfig = { + nameservers?: string[] | undefined + options?: IoK8SApiCoreV1PodDnsConfigOption[] | undefined + searches?: string[] | undefined +} +export type IoK8SApiCoreV1EphemeralContainer = { + args?: string[] | undefined + command?: string[] | undefined + env?: IoK8SApiCoreV1EnvVar[] | undefined + envFrom?: IoK8SApiCoreV1EnvFromSource[] | undefined + image?: string | undefined + imagePullPolicy?: ('Always' | 'IfNotPresent' | 'Never') | undefined + lifecycle?: IoK8SApiCoreV1Lifecycle | undefined + livenessProbe?: IoK8SApiCoreV1Probe | undefined + name: string + ports?: IoK8SApiCoreV1ContainerPort[] | undefined + readinessProbe?: IoK8SApiCoreV1Probe | undefined + resizePolicy?: IoK8SApiCoreV1ContainerResizePolicy[] | undefined + resources?: IoK8SApiCoreV1ResourceRequirements | undefined + restartPolicy?: string | undefined + securityContext?: IoK8SApiCoreV1SecurityContext | undefined + startupProbe?: IoK8SApiCoreV1Probe | undefined + stdin?: boolean | undefined + stdinOnce?: boolean | undefined + targetContainerName?: string | undefined + terminationMessagePath?: string | undefined + terminationMessagePolicy?: ('FallbackToLogsOnError' | 'File') | undefined + tty?: boolean | undefined + volumeDevices?: IoK8SApiCoreV1VolumeDevice[] | undefined + volumeMounts?: IoK8SApiCoreV1VolumeMount[] | undefined + workingDir?: string | undefined +} +export type IoK8SApiCoreV1HostAlias = { + hostnames?: string[] | undefined + ip?: string | undefined +} +export type IoK8SApiCoreV1LocalObjectReference = { + name?: string | undefined +} +export type IoK8SApiCoreV1PodOs = { + name: string +} +export type IoK8SApiCoreV1PodReadinessGate = { + conditionType: string +} +export type IoK8SApiCoreV1ClaimSource = { + resourceClaimName?: string | undefined + resourceClaimTemplateName?: string | undefined +} +export type IoK8SApiCoreV1PodResourceClaim = { + name: string + source?: IoK8SApiCoreV1ClaimSource | undefined +} +export type IoK8SApiCoreV1PodSchedulingGate = { + name: string +} +export type IoK8SApiCoreV1Sysctl = { + name: string + value: string +} +export type IoK8SApiCoreV1PodSecurityContext = { + fsGroup?: number | undefined + fsGroupChangePolicy?: ('Always' | 'OnRootMismatch') | undefined + runAsGroup?: number | undefined + runAsNonRoot?: boolean | undefined + runAsUser?: number | undefined + seLinuxOptions?: IoK8SApiCoreV1SeLinuxOptions | undefined + seccompProfile?: IoK8SApiCoreV1SeccompProfile | undefined + supplementalGroups?: number[] | undefined + sysctls?: IoK8SApiCoreV1Sysctl[] | undefined + windowsOptions?: IoK8SApiCoreV1WindowsSecurityContextOptions | undefined +} +export type IoK8SApiCoreV1Toleration = { + effect?: ('NoExecute' | 'NoSchedule' | 'PreferNoSchedule') | undefined + key?: string | undefined + operator?: ('Equal' | 'Exists') | undefined + tolerationSeconds?: number | undefined + value?: string | undefined +} +export type IoK8SApiCoreV1TopologySpreadConstraint = { + labelSelector?: IoK8SApimachineryPkgApisMetaV1LabelSelector | undefined + matchLabelKeys?: string[] | undefined + maxSkew: number + minDomains?: number | undefined + nodeAffinityPolicy?: ('Honor' | 'Ignore') | undefined + nodeTaintsPolicy?: ('Honor' | 'Ignore') | undefined + topologyKey: string + whenUnsatisfiable: 'DoNotSchedule' | 'ScheduleAnyway' +} +export type IoK8SApiCoreV1AwsElasticBlockStoreVolumeSource = { + fsType?: string | undefined + partition?: number | undefined + readOnly?: boolean | undefined + volumeID: string +} +export type IoK8SApiCoreV1AzureDiskVolumeSource = { + cachingMode?: ('None' | 'ReadOnly' | 'ReadWrite') | undefined + diskName: string + diskURI: string + fsType?: string | undefined + kind?: ('Dedicated' | 'Managed' | 'Shared') | undefined + readOnly?: boolean | undefined +} +export type IoK8SApiCoreV1AzureFileVolumeSource = { + readOnly?: boolean | undefined + secretName: string + shareName: string +} +export type IoK8SApiCoreV1CephFsVolumeSource = { + monitors: string[] + path?: string | undefined + readOnly?: boolean | undefined + secretFile?: string | undefined + secretRef?: IoK8SApiCoreV1LocalObjectReference | undefined + user?: string | undefined +} +export type IoK8SApiCoreV1CinderVolumeSource = { + fsType?: string | undefined + readOnly?: boolean | undefined + secretRef?: IoK8SApiCoreV1LocalObjectReference | undefined + volumeID: string +} +export type IoK8SApiCoreV1KeyToPath = { + key: string + mode?: number | undefined + path: string +} +export type IoK8SApiCoreV1ConfigMapVolumeSource = { + defaultMode?: number | undefined + items?: IoK8SApiCoreV1KeyToPath[] | undefined + name?: string | undefined + optional?: boolean | undefined +} +export type IoK8SApiCoreV1CsiVolumeSource = { + driver: string + fsType?: string | undefined + nodePublishSecretRef?: IoK8SApiCoreV1LocalObjectReference | undefined + readOnly?: boolean | undefined + volumeAttributes?: + | { + [key: string]: string + } + | undefined +} +export type IoK8SApiCoreV1DownwardApiVolumeFile = { + fieldRef?: IoK8SApiCoreV1ObjectFieldSelector | undefined + mode?: number | undefined + path: string + resourceFieldRef?: IoK8SApiCoreV1ResourceFieldSelector | undefined +} +export type IoK8SApiCoreV1DownwardApiVolumeSource = { + defaultMode?: number | undefined + items?: IoK8SApiCoreV1DownwardApiVolumeFile[] | undefined +} +export type IoK8SApiCoreV1EmptyDirVolumeSource = { + medium?: string | undefined + sizeLimit?: IoK8SApimachineryPkgApiResourceQuantity | undefined +} +export type IoK8SApiCoreV1PersistentVolumeClaimTemplate = { + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec: IoK8SApiCoreV1PersistentVolumeClaimSpec +} +export type IoK8SApiCoreV1EphemeralVolumeSource = { + volumeClaimTemplate?: IoK8SApiCoreV1PersistentVolumeClaimTemplate | undefined +} +export type IoK8SApiCoreV1FcVolumeSource = { + fsType?: string | undefined + lun?: number | undefined + readOnly?: boolean | undefined + targetWWNs?: string[] | undefined + wwids?: string[] | undefined +} +export type IoK8SApiCoreV1FlexVolumeSource = { + driver: string + fsType?: string | undefined + options?: + | { + [key: string]: string + } + | undefined + readOnly?: boolean | undefined + secretRef?: IoK8SApiCoreV1LocalObjectReference | undefined +} +export type IoK8SApiCoreV1FlockerVolumeSource = { + datasetName?: string | undefined + datasetUUID?: string | undefined +} +export type IoK8SApiCoreV1GcePersistentDiskVolumeSource = { + fsType?: string | undefined + partition?: number | undefined + pdName: string + readOnly?: boolean | undefined +} +export type IoK8SApiCoreV1GitRepoVolumeSource = { + directory?: string | undefined + repository: string + revision?: string | undefined +} +export type IoK8SApiCoreV1GlusterfsVolumeSource = { + endpoints: string + path: string + readOnly?: boolean | undefined +} +export type IoK8SApiCoreV1HostPathVolumeSource = { + path: string + type?: + | ( + | '' + | 'BlockDevice' + | 'CharDevice' + | 'Directory' + | 'DirectoryOrCreate' + | 'File' + | 'FileOrCreate' + | 'Socket' + ) + | undefined +} +export type IoK8SApiCoreV1IscsiVolumeSource = { + chapAuthDiscovery?: boolean | undefined + chapAuthSession?: boolean | undefined + fsType?: string | undefined + initiatorName?: string | undefined + iqn: string + iscsiInterface?: string | undefined + lun: number + portals?: string[] | undefined + readOnly?: boolean | undefined + secretRef?: IoK8SApiCoreV1LocalObjectReference | undefined + targetPortal: string +} +export type IoK8SApiCoreV1NfsVolumeSource = { + path: string + readOnly?: boolean | undefined + server: string +} +export type IoK8SApiCoreV1PersistentVolumeClaimVolumeSource = { + claimName: string + readOnly?: boolean | undefined +} +export type IoK8SApiCoreV1PhotonPersistentDiskVolumeSource = { + fsType?: string | undefined + pdID: string +} +export type IoK8SApiCoreV1PortworxVolumeSource = { + fsType?: string | undefined + readOnly?: boolean | undefined + volumeID: string +} +export type IoK8SApiCoreV1ClusterTrustBundleProjection = { + labelSelector?: IoK8SApimachineryPkgApisMetaV1LabelSelector | undefined + name?: string | undefined + optional?: boolean | undefined + path: string + signerName?: string | undefined +} +export type IoK8SApiCoreV1ConfigMapProjection = { + items?: IoK8SApiCoreV1KeyToPath[] | undefined + name?: string | undefined + optional?: boolean | undefined +} +export type IoK8SApiCoreV1DownwardApiProjection = { + items?: IoK8SApiCoreV1DownwardApiVolumeFile[] | undefined +} +export type IoK8SApiCoreV1SecretProjection = { + items?: IoK8SApiCoreV1KeyToPath[] | undefined + name?: string | undefined + optional?: boolean | undefined +} +export type IoK8SApiCoreV1ServiceAccountTokenProjection = { + audience?: string | undefined + expirationSeconds?: number | undefined + path: string +} +export type IoK8SApiCoreV1VolumeProjection = { + clusterTrustBundle?: IoK8SApiCoreV1ClusterTrustBundleProjection | undefined + configMap?: IoK8SApiCoreV1ConfigMapProjection | undefined + downwardAPI?: IoK8SApiCoreV1DownwardApiProjection | undefined + secret?: IoK8SApiCoreV1SecretProjection | undefined + serviceAccountToken?: IoK8SApiCoreV1ServiceAccountTokenProjection | undefined +} +export type IoK8SApiCoreV1ProjectedVolumeSource = { + defaultMode?: number | undefined + sources?: IoK8SApiCoreV1VolumeProjection[] | undefined +} +export type IoK8SApiCoreV1QuobyteVolumeSource = { + group?: string | undefined + readOnly?: boolean | undefined + registry: string + tenant?: string | undefined + user?: string | undefined + volume: string +} +export type IoK8SApiCoreV1RbdVolumeSource = { + fsType?: string | undefined + image: string + keyring?: string | undefined + monitors: string[] + pool?: string | undefined + readOnly?: boolean | undefined + secretRef?: IoK8SApiCoreV1LocalObjectReference | undefined + user?: string | undefined +} +export type IoK8SApiCoreV1ScaleIoVolumeSource = { + fsType?: string | undefined + gateway: string + protectionDomain?: string | undefined + readOnly?: boolean | undefined + secretRef: IoK8SApiCoreV1LocalObjectReference + sslEnabled?: boolean | undefined + storageMode?: string | undefined + storagePool?: string | undefined + system: string + volumeName?: string | undefined +} +export type IoK8SApiCoreV1SecretVolumeSource = { + defaultMode?: number | undefined + items?: IoK8SApiCoreV1KeyToPath[] | undefined + optional?: boolean | undefined + secretName?: string | undefined +} +export type IoK8SApiCoreV1StorageOsVolumeSource = { + fsType?: string | undefined + readOnly?: boolean | undefined + secretRef?: IoK8SApiCoreV1LocalObjectReference | undefined + volumeName?: string | undefined + volumeNamespace?: string | undefined +} +export type IoK8SApiCoreV1VsphereVirtualDiskVolumeSource = { + fsType?: string | undefined + storagePolicyID?: string | undefined + storagePolicyName?: string | undefined + volumePath: string +} +export type IoK8SApiCoreV1Volume = { + awsElasticBlockStore?: + | IoK8SApiCoreV1AwsElasticBlockStoreVolumeSource + | undefined + azureDisk?: IoK8SApiCoreV1AzureDiskVolumeSource | undefined + azureFile?: IoK8SApiCoreV1AzureFileVolumeSource | undefined + cephfs?: IoK8SApiCoreV1CephFsVolumeSource | undefined + cinder?: IoK8SApiCoreV1CinderVolumeSource | undefined + configMap?: IoK8SApiCoreV1ConfigMapVolumeSource | undefined + csi?: IoK8SApiCoreV1CsiVolumeSource | undefined + downwardAPI?: IoK8SApiCoreV1DownwardApiVolumeSource | undefined + emptyDir?: IoK8SApiCoreV1EmptyDirVolumeSource | undefined + ephemeral?: IoK8SApiCoreV1EphemeralVolumeSource | undefined + fc?: IoK8SApiCoreV1FcVolumeSource | undefined + flexVolume?: IoK8SApiCoreV1FlexVolumeSource | undefined + flocker?: IoK8SApiCoreV1FlockerVolumeSource | undefined + gcePersistentDisk?: IoK8SApiCoreV1GcePersistentDiskVolumeSource | undefined + gitRepo?: IoK8SApiCoreV1GitRepoVolumeSource | undefined + glusterfs?: IoK8SApiCoreV1GlusterfsVolumeSource | undefined + hostPath?: IoK8SApiCoreV1HostPathVolumeSource | undefined + iscsi?: IoK8SApiCoreV1IscsiVolumeSource | undefined + name: string + nfs?: IoK8SApiCoreV1NfsVolumeSource | undefined + persistentVolumeClaim?: + | IoK8SApiCoreV1PersistentVolumeClaimVolumeSource + | undefined + photonPersistentDisk?: + | IoK8SApiCoreV1PhotonPersistentDiskVolumeSource + | undefined + portworxVolume?: IoK8SApiCoreV1PortworxVolumeSource | undefined + projected?: IoK8SApiCoreV1ProjectedVolumeSource | undefined + quobyte?: IoK8SApiCoreV1QuobyteVolumeSource | undefined + rbd?: IoK8SApiCoreV1RbdVolumeSource | undefined + scaleIO?: IoK8SApiCoreV1ScaleIoVolumeSource | undefined + secret?: IoK8SApiCoreV1SecretVolumeSource | undefined + storageos?: IoK8SApiCoreV1StorageOsVolumeSource | undefined + vsphereVolume?: IoK8SApiCoreV1VsphereVirtualDiskVolumeSource | undefined +} +export type IoK8SApiCoreV1PodSpec = { + activeDeadlineSeconds?: number | undefined + affinity?: IoK8SApiCoreV1Affinity | undefined + automountServiceAccountToken?: boolean | undefined + containers: IoK8SApiCoreV1Container[] + dnsConfig?: IoK8SApiCoreV1PodDnsConfig | undefined + dnsPolicy?: + | ('ClusterFirst' | 'ClusterFirstWithHostNet' | 'Default' | 'None') + | undefined + enableServiceLinks?: boolean | undefined + ephemeralContainers?: IoK8SApiCoreV1EphemeralContainer[] | undefined + hostAliases?: IoK8SApiCoreV1HostAlias[] | undefined + hostIPC?: boolean | undefined + hostNetwork?: boolean | undefined + hostPID?: boolean | undefined + hostUsers?: boolean | undefined + hostname?: string | undefined + imagePullSecrets?: IoK8SApiCoreV1LocalObjectReference[] | undefined + initContainers?: IoK8SApiCoreV1Container[] | undefined + nodeName?: string | undefined + nodeSelector?: + | { + [key: string]: string + } + | undefined + os?: IoK8SApiCoreV1PodOs | undefined + overhead?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + preemptionPolicy?: ('Never' | 'PreemptLowerPriority') | undefined + priority?: number | undefined + priorityClassName?: string | undefined + readinessGates?: IoK8SApiCoreV1PodReadinessGate[] | undefined + resourceClaims?: IoK8SApiCoreV1PodResourceClaim[] | undefined + restartPolicy?: ('Always' | 'Never' | 'OnFailure') | undefined + runtimeClassName?: string | undefined + schedulerName?: string | undefined + schedulingGates?: IoK8SApiCoreV1PodSchedulingGate[] | undefined + securityContext?: IoK8SApiCoreV1PodSecurityContext | undefined + serviceAccount?: string | undefined + serviceAccountName?: string | undefined + setHostnameAsFQDN?: boolean | undefined + shareProcessNamespace?: boolean | undefined + subdomain?: string | undefined + terminationGracePeriodSeconds?: number | undefined + tolerations?: IoK8SApiCoreV1Toleration[] | undefined + topologySpreadConstraints?: + | IoK8SApiCoreV1TopologySpreadConstraint[] + | undefined + volumes?: IoK8SApiCoreV1Volume[] | undefined +} +export type IoK8SApiCoreV1PodCondition = { + lastProbeTime?: IoK8SApimachineryPkgApisMetaV1Time | undefined + lastTransitionTime?: IoK8SApimachineryPkgApisMetaV1Time | undefined + message?: string | undefined + reason?: string | undefined + status: string + type: string +} +export type IoK8SApiCoreV1ContainerStateRunning = { + startedAt?: IoK8SApimachineryPkgApisMetaV1Time | undefined +} +export type IoK8SApiCoreV1ContainerStateTerminated = { + containerID?: string | undefined + exitCode: number + finishedAt?: IoK8SApimachineryPkgApisMetaV1Time | undefined + message?: string | undefined + reason?: string | undefined + signal?: number | undefined + startedAt?: IoK8SApimachineryPkgApisMetaV1Time | undefined +} +export type IoK8SApiCoreV1ContainerStateWaiting = { + message?: string | undefined + reason?: string | undefined +} +export type IoK8SApiCoreV1ContainerState = { + running?: IoK8SApiCoreV1ContainerStateRunning | undefined + terminated?: IoK8SApiCoreV1ContainerStateTerminated | undefined + waiting?: IoK8SApiCoreV1ContainerStateWaiting | undefined +} +export type IoK8SApiCoreV1ContainerStatus = { + allocatedResources?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + containerID?: string | undefined + image: string + imageID: string + lastState?: IoK8SApiCoreV1ContainerState | undefined + name: string + ready: boolean + resources?: IoK8SApiCoreV1ResourceRequirements | undefined + restartCount: number + started?: boolean | undefined + state?: IoK8SApiCoreV1ContainerState | undefined +} +export type IoK8SApiCoreV1HostIp = { + ip?: string | undefined +} +export type IoK8SApiCoreV1PodIp = { + ip?: string | undefined +} +export type IoK8SApiCoreV1PodResourceClaimStatus = { + name: string + resourceClaimName?: string | undefined +} +export type IoK8SApiCoreV1PodStatus = { + conditions?: IoK8SApiCoreV1PodCondition[] | undefined + containerStatuses?: IoK8SApiCoreV1ContainerStatus[] | undefined + ephemeralContainerStatuses?: IoK8SApiCoreV1ContainerStatus[] | undefined + hostIP?: string | undefined + hostIPs?: IoK8SApiCoreV1HostIp[] | undefined + initContainerStatuses?: IoK8SApiCoreV1ContainerStatus[] | undefined + message?: string | undefined + nominatedNodeName?: string | undefined + phase?: + | ('Failed' | 'Pending' | 'Running' | 'Succeeded' | 'Unknown') + | undefined + podIP?: string | undefined + podIPs?: IoK8SApiCoreV1PodIp[] | undefined + qosClass?: ('BestEffort' | 'Burstable' | 'Guaranteed') | undefined + reason?: string | undefined + resize?: string | undefined + resourceClaimStatuses?: IoK8SApiCoreV1PodResourceClaimStatus[] | undefined + startTime?: IoK8SApimachineryPkgApisMetaV1Time | undefined +} +export type IoK8SApiCoreV1Pod = { + apiVersion?: 'v1' | undefined + kind?: 'Pod' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec?: IoK8SApiCoreV1PodSpec | undefined + status?: IoK8SApiCoreV1PodStatus | undefined +} +export type IoK8SApiCoreV1PodList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1Pod[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiPolicyV1Eviction = { + apiVersion?: 'k8s.api.policy.io/v1' | undefined + deleteOptions?: IoK8SApimachineryPkgApisMetaV1DeleteOptions | undefined + kind?: 'Eviction' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined +} +export type IoK8SApiCoreV1PodTemplateSpec = { + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec?: IoK8SApiCoreV1PodSpec | undefined +} +export type IoK8SApiCoreV1PodTemplate = { + apiVersion?: 'v1' | undefined + kind?: 'PodTemplate' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + template?: IoK8SApiCoreV1PodTemplateSpec | undefined +} +export type IoK8SApiCoreV1PodTemplateList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1PodTemplate[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiCoreV1ReplicationControllerSpec = { + minReadySeconds?: number | undefined + replicas?: number | undefined + selector?: + | { + [key: string]: string + } + | undefined + template?: IoK8SApiCoreV1PodTemplateSpec | undefined +} +export type IoK8SApiCoreV1ReplicationControllerCondition = { + lastTransitionTime?: IoK8SApimachineryPkgApisMetaV1Time | undefined + message?: string | undefined + reason?: string | undefined + status: string + type: string +} +export type IoK8SApiCoreV1ReplicationControllerStatus = { + availableReplicas?: number | undefined + conditions?: IoK8SApiCoreV1ReplicationControllerCondition[] | undefined + fullyLabeledReplicas?: number | undefined + observedGeneration?: number | undefined + readyReplicas?: number | undefined + replicas: number +} +export type IoK8SApiCoreV1ReplicationController = { + apiVersion?: 'v1' | undefined + kind?: 'ReplicationController' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec?: IoK8SApiCoreV1ReplicationControllerSpec | undefined + status?: IoK8SApiCoreV1ReplicationControllerStatus | undefined +} +export type IoK8SApiCoreV1ReplicationControllerList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1ReplicationController[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiAutoscalingV1ScaleSpec = { + replicas?: number | undefined +} +export type IoK8SApiAutoscalingV1ScaleStatus = { + replicas: number + selector?: string | undefined +} +export type IoK8SApiAutoscalingV1Scale = { + apiVersion?: 'k8s.api.autoscaling.io/v1' | undefined + kind?: 'Scale' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec?: IoK8SApiAutoscalingV1ScaleSpec | undefined + status?: IoK8SApiAutoscalingV1ScaleStatus | undefined +} +export type IoK8SApiCoreV1ScopedResourceSelectorRequirement = { + operator: 'DoesNotExist' | 'Exists' | 'In' | 'NotIn' + scopeName: + | 'BestEffort' + | 'CrossNamespacePodAffinity' + | 'NotBestEffort' + | 'NotTerminating' + | 'PriorityClass' + | 'Terminating' + values?: string[] | undefined +} +export type IoK8SApiCoreV1ScopeSelector = { + matchExpressions?: + | IoK8SApiCoreV1ScopedResourceSelectorRequirement[] + | undefined +} +export type IoK8SApiCoreV1ResourceQuotaSpec = { + hard?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + scopeSelector?: IoK8SApiCoreV1ScopeSelector | undefined + scopes?: string[] | undefined +} +export type IoK8SApiCoreV1ResourceQuotaStatus = { + hard?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + used?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined +} +export type IoK8SApiCoreV1ResourceQuota = { + apiVersion?: 'v1' | undefined + kind?: 'ResourceQuota' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec?: IoK8SApiCoreV1ResourceQuotaSpec | undefined + status?: IoK8SApiCoreV1ResourceQuotaStatus | undefined +} +export type IoK8SApiCoreV1ResourceQuotaList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1ResourceQuota[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiCoreV1Secret = { + apiVersion?: 'v1' | undefined + data?: + | { + [key: string]: string + } + | undefined + immutable?: boolean | undefined + kind?: 'Secret' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + stringData?: + | { + [key: string]: string + } + | undefined + type?: string | undefined +} +export type IoK8SApiCoreV1SecretList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1Secret[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiCoreV1ServiceAccount = { + apiVersion?: 'v1' | undefined + automountServiceAccountToken?: boolean | undefined + imagePullSecrets?: IoK8SApiCoreV1LocalObjectReference[] | undefined + kind?: 'ServiceAccount' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + secrets?: IoK8SApiCoreV1ObjectReference[] | undefined +} +export type IoK8SApiCoreV1ServiceAccountList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1ServiceAccount[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiAuthenticationV1BoundObjectReference = { + apiVersion?: string | undefined + kind?: string | undefined + name?: string | undefined + uid?: string | undefined +} +export type IoK8SApiAuthenticationV1TokenRequestSpec = { + audiences: string[] + boundObjectRef?: IoK8SApiAuthenticationV1BoundObjectReference | undefined + expirationSeconds?: number | undefined +} +export type IoK8SApiAuthenticationV1TokenRequestStatus = { + expirationTimestamp: IoK8SApimachineryPkgApisMetaV1Time + token: string +} +export type IoK8SApiAuthenticationV1TokenRequest = { + apiVersion?: 'k8s.api.authentication.io/v1' | undefined + kind?: 'TokenRequest' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec: IoK8SApiAuthenticationV1TokenRequestSpec + status?: IoK8SApiAuthenticationV1TokenRequestStatus | undefined +} +export type IoK8SApiCoreV1ServicePort = { + appProtocol?: string | undefined + name?: string | undefined + nodePort?: number | undefined + port: number + protocol?: ('SCTP' | 'TCP' | 'UDP') | undefined + targetPort?: IoK8SApimachineryPkgUtilIntstrIntOrString | undefined +} +export type IoK8SApiCoreV1ClientIpConfig = { + timeoutSeconds?: number | undefined +} +export type IoK8SApiCoreV1SessionAffinityConfig = { + clientIP?: IoK8SApiCoreV1ClientIpConfig | undefined +} +export type IoK8SApiCoreV1ServiceSpec = { + allocateLoadBalancerNodePorts?: boolean | undefined + clusterIP?: string | undefined + clusterIPs?: string[] | undefined + externalIPs?: string[] | undefined + externalName?: string | undefined + externalTrafficPolicy?: + | ('Cluster' | 'Cluster' | 'Local' | 'Local') + | undefined + healthCheckNodePort?: number | undefined + internalTrafficPolicy?: ('Cluster' | 'Local') | undefined + ipFamilies?: string[] | undefined + ipFamilyPolicy?: + | ('PreferDualStack' | 'RequireDualStack' | 'SingleStack') + | undefined + loadBalancerClass?: string | undefined + loadBalancerIP?: string | undefined + loadBalancerSourceRanges?: string[] | undefined + ports?: IoK8SApiCoreV1ServicePort[] | undefined + publishNotReadyAddresses?: boolean | undefined + selector?: + | { + [key: string]: string + } + | undefined + sessionAffinity?: ('ClientIP' | 'None') | undefined + sessionAffinityConfig?: IoK8SApiCoreV1SessionAffinityConfig | undefined + type?: + | ('ClusterIP' | 'ExternalName' | 'LoadBalancer' | 'NodePort') + | undefined +} +export type IoK8SApimachineryPkgApisMetaV1Condition = { + lastTransitionTime: IoK8SApimachineryPkgApisMetaV1Time + message: string + observedGeneration?: number | undefined + reason: string + status: string + type: string +} +export type IoK8SApiCoreV1PortStatus = { + error?: string | undefined + port: number + protocol: 'SCTP' | 'TCP' | 'UDP' +} +export type IoK8SApiCoreV1LoadBalancerIngress = { + hostname?: string | undefined + ip?: string | undefined + ipMode?: string | undefined + ports?: IoK8SApiCoreV1PortStatus[] | undefined +} +export type IoK8SApiCoreV1LoadBalancerStatus = { + ingress?: IoK8SApiCoreV1LoadBalancerIngress[] | undefined +} +export type IoK8SApiCoreV1ServiceStatus = { + conditions?: IoK8SApimachineryPkgApisMetaV1Condition[] | undefined + loadBalancer?: IoK8SApiCoreV1LoadBalancerStatus | undefined +} +export type IoK8SApiCoreV1Service = { + apiVersion?: 'v1' | undefined + kind?: 'Service' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec?: IoK8SApiCoreV1ServiceSpec | undefined + status?: IoK8SApiCoreV1ServiceStatus | undefined +} +export type IoK8SApiCoreV1ServiceList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1Service[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiCoreV1ConfigMapNodeConfigSource = { + kubeletConfigKey: string + name: string + namespace: string + resourceVersion?: string | undefined + uid?: string | undefined +} +export type IoK8SApiCoreV1NodeConfigSource = { + configMap?: IoK8SApiCoreV1ConfigMapNodeConfigSource | undefined +} +export type IoK8SApiCoreV1Taint = { + effect: 'NoExecute' | 'NoSchedule' | 'PreferNoSchedule' + key: string + timeAdded?: IoK8SApimachineryPkgApisMetaV1Time | undefined + value?: string | undefined +} +export type IoK8SApiCoreV1NodeSpec = { + configSource?: IoK8SApiCoreV1NodeConfigSource | undefined + externalID?: string | undefined + podCIDR?: string | undefined + podCIDRs?: string[] | undefined + providerID?: string | undefined + taints?: IoK8SApiCoreV1Taint[] | undefined + unschedulable?: boolean | undefined +} +export type IoK8SApiCoreV1NodeAddress = { + address: string + type: string +} +export type IoK8SApiCoreV1NodeCondition = { + lastHeartbeatTime?: IoK8SApimachineryPkgApisMetaV1Time | undefined + lastTransitionTime?: IoK8SApimachineryPkgApisMetaV1Time | undefined + message?: string | undefined + reason?: string | undefined + status: string + type: string +} +export type IoK8SApiCoreV1NodeConfigStatus = { + active?: IoK8SApiCoreV1NodeConfigSource | undefined + assigned?: IoK8SApiCoreV1NodeConfigSource | undefined + error?: string | undefined + lastKnownGood?: IoK8SApiCoreV1NodeConfigSource | undefined +} +export type IoK8SApiCoreV1DaemonEndpoint = { + Port: number +} +export type IoK8SApiCoreV1NodeDaemonEndpoints = { + kubeletEndpoint?: IoK8SApiCoreV1DaemonEndpoint | undefined +} +export type IoK8SApiCoreV1ContainerImage = { + names?: string[] | undefined + sizeBytes?: number | undefined +} +export type IoK8SApiCoreV1NodeSystemInfo = { + architecture: string + bootID: string + containerRuntimeVersion: string + kernelVersion: string + kubeProxyVersion: string + kubeletVersion: string + machineID: string + operatingSystem: string + osImage: string + systemUUID: string +} +export type IoK8SApiCoreV1AttachedVolume = { + devicePath: string + name: string +} +export type IoK8SApiCoreV1NodeStatus = { + addresses?: IoK8SApiCoreV1NodeAddress[] | undefined + allocatable?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + capacity?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + conditions?: IoK8SApiCoreV1NodeCondition[] | undefined + config?: IoK8SApiCoreV1NodeConfigStatus | undefined + daemonEndpoints?: IoK8SApiCoreV1NodeDaemonEndpoints | undefined + images?: IoK8SApiCoreV1ContainerImage[] | undefined + nodeInfo?: IoK8SApiCoreV1NodeSystemInfo | undefined + phase?: ('Pending' | 'Running' | 'Terminated') | undefined + volumesAttached?: IoK8SApiCoreV1AttachedVolume[] | undefined + volumesInUse?: string[] | undefined +} +export type IoK8SApiCoreV1Node = { + apiVersion?: 'v1' | undefined + kind?: 'Node' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec?: IoK8SApiCoreV1NodeSpec | undefined + status?: IoK8SApiCoreV1NodeStatus | undefined +} +export type IoK8SApiCoreV1NodeList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1Node[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApiCoreV1AzureFilePersistentVolumeSource = { + readOnly?: boolean | undefined + secretName: string + secretNamespace?: string | undefined + shareName: string +} +export type IoK8SApiCoreV1SecretReference = { + name?: string | undefined + namespace?: string | undefined +} +export type IoK8SApiCoreV1CephFsPersistentVolumeSource = { + monitors: string[] + path?: string | undefined + readOnly?: boolean | undefined + secretFile?: string | undefined + secretRef?: IoK8SApiCoreV1SecretReference | undefined + user?: string | undefined +} +export type IoK8SApiCoreV1CinderPersistentVolumeSource = { + fsType?: string | undefined + readOnly?: boolean | undefined + secretRef?: IoK8SApiCoreV1SecretReference | undefined + volumeID: string +} +export type IoK8SApiCoreV1CsiPersistentVolumeSource = { + controllerExpandSecretRef?: IoK8SApiCoreV1SecretReference | undefined + controllerPublishSecretRef?: IoK8SApiCoreV1SecretReference | undefined + driver: string + fsType?: string | undefined + nodeExpandSecretRef?: IoK8SApiCoreV1SecretReference | undefined + nodePublishSecretRef?: IoK8SApiCoreV1SecretReference | undefined + nodeStageSecretRef?: IoK8SApiCoreV1SecretReference | undefined + readOnly?: boolean | undefined + volumeAttributes?: + | { + [key: string]: string + } + | undefined + volumeHandle: string +} +export type IoK8SApiCoreV1FlexPersistentVolumeSource = { + driver: string + fsType?: string | undefined + options?: + | { + [key: string]: string + } + | undefined + readOnly?: boolean | undefined + secretRef?: IoK8SApiCoreV1SecretReference | undefined +} +export type IoK8SApiCoreV1GlusterfsPersistentVolumeSource = { + endpoints: string + endpointsNamespace?: string | undefined + path: string + readOnly?: boolean | undefined +} +export type IoK8SApiCoreV1IscsiPersistentVolumeSource = { + chapAuthDiscovery?: boolean | undefined + chapAuthSession?: boolean | undefined + fsType?: string | undefined + initiatorName?: string | undefined + iqn: string + iscsiInterface?: string | undefined + lun: number + portals?: string[] | undefined + readOnly?: boolean | undefined + secretRef?: IoK8SApiCoreV1SecretReference | undefined + targetPortal: string +} +export type IoK8SApiCoreV1LocalVolumeSource = { + fsType?: string | undefined + path: string +} +export type IoK8SApiCoreV1VolumeNodeAffinity = { + required?: IoK8SApiCoreV1NodeSelector | undefined +} +export type IoK8SApiCoreV1RbdPersistentVolumeSource = { + fsType?: string | undefined + image: string + keyring?: string | undefined + monitors: string[] + pool?: string | undefined + readOnly?: boolean | undefined + secretRef?: IoK8SApiCoreV1SecretReference | undefined + user?: string | undefined +} +export type IoK8SApiCoreV1ScaleIoPersistentVolumeSource = { + fsType?: string | undefined + gateway: string + protectionDomain?: string | undefined + readOnly?: boolean | undefined + secretRef: IoK8SApiCoreV1SecretReference + sslEnabled?: boolean | undefined + storageMode?: string | undefined + storagePool?: string | undefined + system: string + volumeName?: string | undefined +} +export type IoK8SApiCoreV1StorageOsPersistentVolumeSource = { + fsType?: string | undefined + readOnly?: boolean | undefined + secretRef?: IoK8SApiCoreV1ObjectReference | undefined + volumeName?: string | undefined + volumeNamespace?: string | undefined +} +export type IoK8SApiCoreV1PersistentVolumeSpec = { + accessModes?: string[] | undefined + awsElasticBlockStore?: + | IoK8SApiCoreV1AwsElasticBlockStoreVolumeSource + | undefined + azureDisk?: IoK8SApiCoreV1AzureDiskVolumeSource | undefined + azureFile?: IoK8SApiCoreV1AzureFilePersistentVolumeSource | undefined + capacity?: + | { + [key: string]: IoK8SApimachineryPkgApiResourceQuantity + } + | undefined + cephfs?: IoK8SApiCoreV1CephFsPersistentVolumeSource | undefined + cinder?: IoK8SApiCoreV1CinderPersistentVolumeSource | undefined + claimRef?: IoK8SApiCoreV1ObjectReference | undefined + csi?: IoK8SApiCoreV1CsiPersistentVolumeSource | undefined + fc?: IoK8SApiCoreV1FcVolumeSource | undefined + flexVolume?: IoK8SApiCoreV1FlexPersistentVolumeSource | undefined + flocker?: IoK8SApiCoreV1FlockerVolumeSource | undefined + gcePersistentDisk?: IoK8SApiCoreV1GcePersistentDiskVolumeSource | undefined + glusterfs?: IoK8SApiCoreV1GlusterfsPersistentVolumeSource | undefined + hostPath?: IoK8SApiCoreV1HostPathVolumeSource | undefined + iscsi?: IoK8SApiCoreV1IscsiPersistentVolumeSource | undefined + local?: IoK8SApiCoreV1LocalVolumeSource | undefined + mountOptions?: string[] | undefined + nfs?: IoK8SApiCoreV1NfsVolumeSource | undefined + nodeAffinity?: IoK8SApiCoreV1VolumeNodeAffinity | undefined + persistentVolumeReclaimPolicy?: ('Delete' | 'Recycle' | 'Retain') | undefined + photonPersistentDisk?: + | IoK8SApiCoreV1PhotonPersistentDiskVolumeSource + | undefined + portworxVolume?: IoK8SApiCoreV1PortworxVolumeSource | undefined + quobyte?: IoK8SApiCoreV1QuobyteVolumeSource | undefined + rbd?: IoK8SApiCoreV1RbdPersistentVolumeSource | undefined + scaleIO?: IoK8SApiCoreV1ScaleIoPersistentVolumeSource | undefined + storageClassName?: string | undefined + storageos?: IoK8SApiCoreV1StorageOsPersistentVolumeSource | undefined + volumeAttributesClassName?: string | undefined + volumeMode?: ('Block' | 'Filesystem') | undefined + vsphereVolume?: IoK8SApiCoreV1VsphereVirtualDiskVolumeSource | undefined +} +export type IoK8SApiCoreV1PersistentVolumeStatus = { + lastPhaseTransitionTime?: IoK8SApimachineryPkgApisMetaV1Time | undefined + message?: string | undefined + phase?: + | ('Available' | 'Bound' | 'Failed' | 'Pending' | 'Released') + | undefined + reason?: string | undefined +} +export type IoK8SApiCoreV1PersistentVolume = { + apiVersion?: 'v1' | undefined + kind?: 'PersistentVolume' | undefined + metadata?: IoK8SApimachineryPkgApisMetaV1ObjectMeta | undefined + spec?: IoK8SApiCoreV1PersistentVolumeSpec | undefined + status?: IoK8SApiCoreV1PersistentVolumeStatus | undefined +} +export type IoK8SApiCoreV1PersistentVolumeList = { + apiVersion: 'v1' + items: IoK8SApiCoreV1PersistentVolume[] + kind: 'List' + metadata: IoK8SApimachineryPkgApisMetaV1ListMeta +} +export type IoK8SApimachineryPkgRuntimeRawExtension = object +export type IoK8SApimachineryPkgApisMetaV1WatchEvent = { + object: IoK8SApimachineryPkgRuntimeRawExtension + type: string +} diff --git a/packages/kubekit-prepare/src/lib.ts b/packages/kubekit-prepare/src/lib.ts new file mode 100644 index 00000000..8fe32047 --- /dev/null +++ b/packages/kubekit-prepare/src/lib.ts @@ -0,0 +1,41 @@ +import { ResourceVerb } from './getRules' + +export type HttpMethods = + | 'get' + | 'put' + | 'post' + | 'delete' + | 'options' + | 'head' + | 'patch' + | 'trace' + +export function mapK8sVerbToHttpMethod(verb: ResourceVerb): HttpMethods { + switch (verb) { + case 'get': + case 'list': + case 'watch': + return 'get' + case 'create': + return 'post' + case 'update': + return 'put' + case 'patch': + return 'patch' + case 'delete': + return 'delete' + case '*': + throw Error("don't * come here") + default: + const _: unknown = verb + throw Error(`Unsupported Kubernetes verb: ${_}`) + } +} + +export function assertNotNull( + value: T | null | undefined +): asserts value is NonNullable { + if (value === null || value === undefined) { + throw new Error('Assertion failed: value is null or undefined') + } +} diff --git a/packages/kubekit-prepare/src/patchOpenApi/applyPatch.ts b/packages/kubekit-prepare/src/patchOpenApi/applyPatch.ts new file mode 100644 index 00000000..29aefbe0 --- /dev/null +++ b/packages/kubekit-prepare/src/patchOpenApi/applyPatch.ts @@ -0,0 +1,66 @@ +import { OpenAPIV3 } from 'openapi-types' + +export function patchApplyPatch(doc: OpenAPIV3.Document) { + if (!doc.components?.schemas) { + doc.components = { schemas: {} } + } + + for (const path in doc.paths) { + if (path.endsWith('/status')) { + continue + } + const applyPatchRequestBody = ( + doc.paths[path]?.patch?.requestBody as OpenAPIV3.RequestBodyObject + )?.content['application/apply-patch+yaml'] + + if (!applyPatchRequestBody?.schema) { + continue + } + function getKind() { + if ( + applyPatchRequestBody.schema && + '$ref' in applyPatchRequestBody.schema + ) { + // a = "#/components/schemas/io.k8s.api.core.v1.ConfigMap" + const a = applyPatchRequestBody.schema.$ref.split('/') + // b = "io.k8s.api.core.v1.ConfigMap" + const b = a[a.length - 1] + const c = b.split('.') + // ConfigMap + return c[c.length - 1] + } + } + const kind = getKind() + const words = path.split('/') + const isCore = words.length <= 7 + if (words[2] && words[3] && kind) { + applyPatchRequestBody.schema = { + allOf: [ + applyPatchRequestBody.schema, + { + type: 'object', + properties: { + apiVersion: { + type: 'string', + enum: [isCore ? words[2] : `${words[2]}/${words[3]}`], + }, + kind: { + type: 'string', + ...(kind + ? { + enum: [kind], + } + : {}), + }, + }, + required: ['apiVersion', 'kind'], + }, + ], + } + } else { + throw Error(`impossible path: ${path}`) + } + } + + return doc +} diff --git a/packages/kubekit-prepare/src/patchOpenApi/gvk.ts b/packages/kubekit-prepare/src/patchOpenApi/gvk.ts new file mode 100644 index 00000000..18afdcc1 --- /dev/null +++ b/packages/kubekit-prepare/src/patchOpenApi/gvk.ts @@ -0,0 +1,44 @@ +import { OpenAPIV3 } from 'openapi-types' + +export function patchGvk(doc: OpenAPIV3.Document) { + if (!doc.components?.schemas) { + return doc + } + + for (const schemaName in doc.components.schemas) { + const words = schemaName.split('.') + const schema = doc.components.schemas[schemaName] + if ( + 'properties' in schema && + schema.properties && + schema.properties['kind'] && + 'type' in schema.properties['kind'] && + schema.properties['apiVersion'] && + 'type' in schema.properties['apiVersion'] && + schema.properties['metadata'] + ) { + if (schema.properties['items']) { + schema.properties['kind'].enum = ['List'] + schema.properties['apiVersion'].enum = ['v1'] + schema.required = ['kind', 'apiVersion', 'metadata', 'items'] + } else if (words[words.length - 1]) { + schema.properties['kind'].enum = [words[words.length - 1]] + // "dev.knative.serving.v1.Service" + // "io.k8s.api.core.v1.Pod" + function getApiVersion() { + if (schemaName.startsWith('io.k8s.api.core.')) { + return words[words.length - 2] + } + + const [first, ...center] = words + center.pop() + const last = center.pop() + return `${center.join('.')}.${first}/${last}` + } + schema.properties['apiVersion'].enum = [getApiVersion()] + } + } + } + + return doc +} diff --git a/packages/kubekit-prepare/src/patchOpenApi/index.ts b/packages/kubekit-prepare/src/patchOpenApi/index.ts new file mode 100644 index 00000000..490cfc61 --- /dev/null +++ b/packages/kubekit-prepare/src/patchOpenApi/index.ts @@ -0,0 +1,10 @@ +import { OpenAPIV3 } from 'openapi-types' +import { patchOp } from './op' +import { patchApplyPatch } from './applyPatch' +import { patchGvk } from './gvk' + +export const patchFunctions = [ + patchOp, + patchApplyPatch, + patchGvk, +] satisfies Array<(doc: OpenAPIV3.Document) => OpenAPIV3.Document> diff --git a/packages/kubekit-prepare/src/patchOpenApi/op.ts b/packages/kubekit-prepare/src/patchOpenApi/op.ts new file mode 100644 index 00000000..3fc3a1b1 --- /dev/null +++ b/packages/kubekit-prepare/src/patchOpenApi/op.ts @@ -0,0 +1,195 @@ +import type { OpenAPIV3 } from 'openapi-types' + +export function patchOp(doc: OpenAPIV3.Document) { + if (!doc.components?.schemas) { + doc.components = { schemas: {} } + } + let hasJsonPatch = false + + for (const path in doc.paths) { + const putContent = ( + doc.paths[path]?.put?.requestBody as OpenAPIV3.RequestBodyObject + )?.content + const putRequestBody = + putContent?.['*/*'] || + putContent?.['application/json'] || + putContent?.['application/yaml'] + if (!putRequestBody) { + continue + } + const applyPatchRequestBody = ( + doc.paths[path]?.patch?.requestBody as OpenAPIV3.RequestBodyObject + )?.content['application/apply-patch+yaml'] + + if (applyPatchRequestBody) { + applyPatchRequestBody.schema = putRequestBody.schema + } + + const strategicMergePatchRequestBody = ( + doc.paths[path]?.patch?.requestBody as OpenAPIV3.RequestBodyObject + )?.content['application/strategic-merge-patch+json'] + if (strategicMergePatchRequestBody) { + strategicMergePatchRequestBody.schema = putRequestBody.schema + } + + const mergePatchRequestBody = ( + doc.paths[path]?.patch?.requestBody as OpenAPIV3.RequestBodyObject + )?.content['application/merge-patch+json'] + if (mergePatchRequestBody) { + mergePatchRequestBody.schema = putRequestBody.schema + } + + const jsonPatchRequestBody = ( + doc.paths[path]?.patch?.requestBody as OpenAPIV3.RequestBodyObject + )?.content['application/json-patch+json'] + if (jsonPatchRequestBody) { + jsonPatchRequestBody.schema = { + $ref: '#/components/schemas/JsonPatchOperations', + } + hasJsonPatch = true + } + } + + if (hasJsonPatch) { + if (doc.components.schemas) { + const value = { + oneOf: [ + { + type: 'string', + }, + { + type: 'number', + }, + { + type: 'boolean', + }, + { + type: 'array', + }, + { + type: 'object', + }, + ], + } + + doc.components.schemas['JsonPatchOperation'] = { + type: 'object', + oneOf: [ + { + $ref: '#/components/schemas/AddOperation', + }, + { + $ref: '#/components/schemas/RemoveOperation', + }, + { + $ref: '#/components/schemas/ReplaceOperation', + }, + { + $ref: '#/components/schemas/MoveOperation', + }, + { + $ref: '#/components/schemas/CopyOperation', + }, + { + $ref: '#/components/schemas/TestOperation', + }, + ], + } + doc.components.schemas['AddOperation'] = { + type: 'object', + required: ['op', 'path', 'value'], + properties: { + op: { + type: 'string', + enum: ['add'], + }, + path: { + type: 'string', + }, + value: value as any, + }, + } + doc.components.schemas['RemoveOperation'] = { + type: 'object', + required: ['op', 'path'], + properties: { + op: { + type: 'string', + enum: ['remove'], + }, + path: { + type: 'string', + }, + }, + } + doc.components.schemas['ReplaceOperation'] = { + type: 'object', + required: ['op', 'path', 'value'], + properties: { + op: { + type: 'string', + enum: ['replace'], + }, + path: { + type: 'string', + }, + value: value as any, + }, + } + doc.components.schemas['MoveOperation'] = { + type: 'object', + required: ['op', 'path', 'from'], + properties: { + op: { + type: 'string', + enum: ['move'], + }, + path: { + type: 'string', + }, + from: { + type: 'string', + }, + }, + } + doc.components.schemas['CopyOperation'] = { + type: 'object', + required: ['op', 'path', 'from'], + properties: { + op: { + type: 'string', + enum: ['copy'], + }, + path: { + type: 'string', + }, + from: { + type: 'string', + }, + }, + } + doc.components.schemas['TestOperation'] = { + type: 'object', + required: ['op', 'path', 'value'], + properties: { + op: { + type: 'string', + enum: ['test'], + }, + path: { + type: 'string', + }, + value: value as any, + }, + } + doc.components.schemas['JsonPatchOperations'] = { + type: 'array', + items: { + $ref: '#/components/schemas/JsonPatchOperation', + }, + } + } + } + + return doc +} diff --git a/packages/kubekit-prepare/tests/test.yaml b/packages/kubekit-prepare/tests/test.yaml new file mode 100644 index 00000000..f23becb8 --- /dev/null +++ b/packages/kubekit-prepare/tests/test.yaml @@ -0,0 +1,164 @@ +apiVersion: v1 +kind: ServiceAccount +metadata: + name: test + namespace: default + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: Role +metadata: + namespace: default + name: pod-ingress-creator +rules: + - apiGroups: [''] + resources: ['pods'] + verbs: ['create'] + - apiGroups: ['networking.k8s.io'] + resources: ['ingresses'] + verbs: ['create', 'deletecollection'] + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: RoleBinding +metadata: + name: pod-ingress-creator-binding + namespace: default +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: Role + name: pod-ingress-creator +subjects: + - kind: ServiceAccount + name: test + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: Role +metadata: + namespace: kube-system + name: pod-ingress-creator +rules: + - apiGroups: [''] + resources: ['pods'] + verbs: ['create'] + - apiGroups: ['networking.k8s.io'] + resources: ['ingresses'] + verbs: ['create'] + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: RoleBinding +metadata: + name: pod-ingress-creator-binding + namespace: kube-system +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: Role + name: pod-ingress-creator +subjects: + - kind: ServiceAccount + name: test + namespace: default + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: Role +metadata: + namespace: kube-system + name: endpoint-viewer +rules: + - apiGroups: [''] + resources: ['endpoints'] + verbs: ['list'] + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: RoleBinding +metadata: + name: endpoint-viewer-binding + namespace: kube-system +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: Role + name: endpoint-viewer +subjects: + - kind: ServiceAccount + name: test + namespace: default + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + name: configmap-manager +rules: + - apiGroups: [''] + resources: ['configmaps'] + verbs: ['get', 'list', 'watch', 'create', 'update', 'patch', 'delete'] + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRoleBinding +metadata: + name: configmap-manager-binding +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: configmap-manager +subjects: + - kind: ServiceAccount + name: test + namespace: default + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRoleBinding +metadata: + name: configmap-manager-binding +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: configmap-manager +subjects: + - kind: ServiceAccount + name: test + namespace: default + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRoleBinding +metadata: + name: override-pods +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: override-pods +subjects: + - kind: ServiceAccount + name: test + namespace: default + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRole +metadata: + name: override-pods +rules: + - apiGroups: [''] + resources: ['pods'] + verbs: ['*'] + +--- +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRoleBinding +metadata: + name: not-exists +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: not-exists +subjects: + - kind: ServiceAccount + name: test + namespace: default diff --git a/packages/kubekit-prepare/tests/test1.config.ts b/packages/kubekit-prepare/tests/test1.config.ts new file mode 100644 index 00000000..5423ef0f --- /dev/null +++ b/packages/kubekit-prepare/tests/test1.config.ts @@ -0,0 +1,10 @@ +import { ConfigFile } from '../src/config' + +const config: ConfigFile = { + kind: 'ServiceAccount', + name: 'ttl-after-finished-controller', + namespace: 'kube-system', + outputFile: './ttl-after-finished-controller.openapi.json', +} + +export default config diff --git a/packages/kubekit-prepare/tsconfig.json b/packages/kubekit-prepare/tsconfig.json new file mode 100644 index 00000000..5cfe8b8b --- /dev/null +++ b/packages/kubekit-prepare/tsconfig.json @@ -0,0 +1,74 @@ +{ + "compilerOptions": { + /* Visit https://aka.ms/tsconfig.json to read more about this file */ + + /* Basic Options */ + // "incremental": true, /* Enable incremental compilation */ + "target": "es2019" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */, + "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */, + // "lib": [], /* Specify library files to be included in the compilation. */ + // "allowJs": true, /* Allow javascript files to be compiled. */ + // "checkJs": true, /* Report errors in .js files. */ + // "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */ + "declaration": true /* Generates corresponding '.d.ts' file. */, + // "declarationMap": true, /* Generates a sourcemap for each corresponding '.d.ts' file. */ + "sourceMap": true /* Generates corresponding '.map' file. */, + // "outFile": "./", /* Concatenate and emit output to single file. */ + "outDir": "lib" /* Redirect output structure to the directory. */, + "rootDir": "src" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */, + // "composite": true, /* Enable project compilation */ + // "tsBuildInfoFile": "./", /* Specify file to store incremental compilation information */ + // "removeComments": true, /* Do not emit comments to output. */ + // "noEmit": true, /* Do not emit outputs. */ + // "importHelpers": true, /* Import emit helpers from 'tslib'. */ + // "downlevelIteration": true, /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */ + // "isolatedModules": true, /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */ + + /* Strict Type-Checking Options */ + "strict": true /* Enable all strict type-checking options. */, + // "noImplicitAny": true, /* Raise error on expressions and declarations with an implied 'any' type. */ + // "strictNullChecks": true, /* Enable strict null checks. */ + // "strictFunctionTypes": true, /* Enable strict checking of function types. */ + // "strictBindCallApply": true, /* Enable strict 'bind', 'call', and 'apply' methods on functions. */ + // "strictPropertyInitialization": true, /* Enable strict checking of property initialization in classes. */ + // "noImplicitThis": true, /* Raise error on 'this' expressions with an implied 'any' type. */ + // "alwaysStrict": true, /* Parse in strict mode and emit "use strict" for each source file. */ + + /* Additional Checks */ + "noUnusedLocals": false /* Report errors on unused locals. */, + "resolveJsonModule": true, + // "noUnusedParameters": true, /* Report errors on unused parameters. */ + // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */ + // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */ + // "noUncheckedIndexedAccess": true, /* Include 'undefined' in index signature results */ + + /* Module Resolution Options */ + "moduleResolution": "node" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */, + // "baseUrl": "./", /* Base directory to resolve non-absolute module names. */ + // "paths": {}, /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */ + // "rootDirs": [], /* List of root folders whose combined content represents the structure of the project at runtime. */ + // "typeRoots": [], /* List of folders to include type definitions from. */ + "types": [ + "node" + ] /* Type declaration files to be included in compilation. */, + // "allowSyntheticDefaultImports": true, /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */ + "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */, + // "preserveSymlinks": true, /* Do not resolve the real path of symlinks. */ + // "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */ + + /* Source Map Options */ + // "sourceRoot": "", /* Specify the location where debugger should locate TypeScript files instead of source locations. */ + // "mapRoot": "", /* Specify the location where debugger should locate map files instead of generated locations. */ + // "inlineSourceMap": true, /* Emit a single file with source maps instead of having a separate file. */ + // "inlineSources": true, /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */ + + /* Experimental Options */ + // "experimentalDecorators": true, /* Enables experimental support for ES7 decorators. */ + // "emitDecoratorMetadata": true, /* Enables experimental support for emitting type metadata for decorators. */ + + /* Advanced Options */ + "skipLibCheck": true /* Skip type checking of declaration files. */, + "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */ + }, + "exclude": ["test", "lib", "gen-config", "tests"] +} diff --git a/packages/kubekit-prepare/yarn.lock b/packages/kubekit-prepare/yarn.lock new file mode 100644 index 00000000..fb201fdf --- /dev/null +++ b/packages/kubekit-prepare/yarn.lock @@ -0,0 +1,1198 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@apidevtools/json-schema-ref-parser@9.0.6": + version "9.0.6" + resolved "https://registry.yarnpkg.com/@apidevtools/json-schema-ref-parser/-/json-schema-ref-parser-9.0.6.tgz#5d9000a3ac1fd25404da886da6b266adcd99cf1c" + integrity sha512-M3YgsLjI0lZxvrpeGVk9Ap032W6TPQkH6pRAZz81Ac3WUNF79VQooAFnp8umjvVzUmD93NkogxEwbSce7qMsUg== + dependencies: + "@jsdevtools/ono" "^7.1.3" + call-me-maybe "^1.0.1" + js-yaml "^3.13.1" + +"@apidevtools/openapi-schemas@^2.1.0": + version "2.1.0" + resolved "https://registry.yarnpkg.com/@apidevtools/openapi-schemas/-/openapi-schemas-2.1.0.tgz#9fa08017fb59d80538812f03fc7cac5992caaa17" + integrity sha512-Zc1AlqrJlX3SlpupFGpiLi2EbteyP7fXmUOGup6/DnkRgjP9bgMM/ag+n91rsv0U1Gpz0H3VILA/o3bW7Ua6BQ== + +"@apidevtools/swagger-methods@^3.0.2": + version "3.0.2" + resolved "https://registry.yarnpkg.com/@apidevtools/swagger-methods/-/swagger-methods-3.0.2.tgz#b789a362e055b0340d04712eafe7027ddc1ac267" + integrity sha512-QAkD5kK2b1WfjDS/UQn/qQkbwF31uqRjPTrsCs5ZG9BQGAkjwvqGFjjPqAuzac/IYzpPtRzjCP1WrTuAIjMrXg== + +"@apidevtools/swagger-parser@^10.0.2", "@apidevtools/swagger-parser@^10.1.0": + version "10.1.0" + resolved "https://registry.yarnpkg.com/@apidevtools/swagger-parser/-/swagger-parser-10.1.0.tgz#a987d71e5be61feb623203be0c96e5985b192ab6" + integrity sha512-9Kt7EuS/7WbMAUv2gSziqjvxwDbFSg3Xeyfuj5laUODX8o/k/CpsAKiQ8W7/R88eXFTMbJYg6+7uAmOWNKmwnw== + dependencies: + "@apidevtools/json-schema-ref-parser" "9.0.6" + "@apidevtools/openapi-schemas" "^2.1.0" + "@apidevtools/swagger-methods" "^3.0.2" + "@jsdevtools/ono" "^7.1.3" + ajv "^8.6.3" + ajv-draft-04 "^1.0.0" + call-me-maybe "^1.0.1" + +"@esbuild/aix-ppc64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.21.1.tgz#044268dc9ca4dc67f8d4aad8f51cfb894bfd7114" + integrity sha512-O7yppwipkXvnEPjzkSXJRk2g4bS8sUx9p9oXHq9MU/U7lxUzZVsnFZMDTmeeX9bfQxrFcvOacl/ENgOh0WP9pA== + +"@esbuild/android-arm64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.21.1.tgz#76aacd934449e541f05b66d5ec8cbff96ec2ae81" + integrity sha512-jXhccq6es+onw7x8MxoFnm820mz7sGa9J14kLADclmiEUH4fyj+FjR6t0M93RgtlI/awHWhtF0Wgfhqgf9gDZA== + +"@esbuild/android-arm@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.21.1.tgz#8247c5aef933a212bca261290f6e43a9dca07cc5" + integrity sha512-hh3jKWikdnTtHCglDAeVO3Oyh8MaH8xZUaWMiCCvJ9/c3NtPqZq+CACOlGTxhddypXhl+8B45SeceYBfB/e8Ow== + +"@esbuild/android-x64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.21.1.tgz#80cbfa35412299edefbc4ab78064f0b66e448008" + integrity sha512-NPObtlBh4jQHE01gJeucqEhdoD/4ya2owSIS8lZYS58aR0x7oZo9lB2lVFxgTANSa5MGCBeoQtr+yA9oKCGPvA== + +"@esbuild/darwin-arm64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.21.1.tgz#154167fb9e54017dac4b343f8e5e25c9d9324036" + integrity sha512-BLT7TDzqsVlQRmJfO/FirzKlzmDpBWwmCUlyggfzUwg1cAxVxeA4O6b1XkMInlxISdfPAOunV9zXjvh5x99Heg== + +"@esbuild/darwin-x64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.21.1.tgz#db971502c9fa204906b89e489810c902bf6d9afb" + integrity sha512-D3h3wBQmeS/vp93O4B+SWsXB8HvRDwMyhTNhBd8yMbh5wN/2pPWRW5o/hM3EKgk9bdKd9594lMGoTCTiglQGRQ== + +"@esbuild/freebsd-arm64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.1.tgz#f0f3bc20c23af999bd696099a324dceb66d77761" + integrity sha512-/uVdqqpNKXIxT6TyS/oSK4XE4xWOqp6fh4B5tgAwozkyWdylcX+W4YF2v6SKsL4wCQ5h1bnaSNjWPXG/2hp8AQ== + +"@esbuild/freebsd-x64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.21.1.tgz#d36af9085edb34244b41e5a57640e6b4452cbec2" + integrity sha512-paAkKN1n1jJitw+dAoR27TdCzxRl1FOEITx3h201R6NoXUojpMzgMLdkXVgCvaCSCqwYkeGLoe9UVNRDKSvQgw== + +"@esbuild/linux-arm64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.21.1.tgz#9d2ad42eea33b2a9571f13e7ecc39ee9d3ff0c6d" + integrity sha512-G65d08YoH00TL7Xg4LaL3gLV21bpoAhQ+r31NUu013YB7KK0fyXIt05VbsJtpqh/6wWxoLJZOvQHYnodRrnbUQ== + +"@esbuild/linux-arm@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.21.1.tgz#d6f7c5873479dd97148bef3e3a7f09d486642883" + integrity sha512-tRHnxWJnvNnDpNVnsyDhr1DIQZUfCXlHSCDohbXFqmg9W4kKR7g8LmA3kzcwbuxbRMKeit8ladnCabU5f2traA== + +"@esbuild/linux-ia32@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.21.1.tgz#8f2aef34a31c8d16dbce0b8679021f4881f38efe" + integrity sha512-tt/54LqNNAqCz++QhxoqB9+XqdsaZOtFD/srEhHYwBd3ZUOepmR1Eeot8bS+Q7BiEvy9vvKbtpHf+r6q8hF5UA== + +"@esbuild/linux-loong64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.21.1.tgz#44461ea2388efbafa6cf12b2bc1407a5388da066" + integrity sha512-MhNalK6r0nZD0q8VzUBPwheHzXPr9wronqmZrewLfP7ui9Fv1tdPmg6e7A8lmg0ziQCziSDHxh3cyRt4YMhGnQ== + +"@esbuild/linux-mips64el@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.21.1.tgz#754d533a4fef4b0790d82bfe1e82d6876f18370e" + integrity sha512-YCKVY7Zen5rwZV+nZczOhFmHaeIxR4Zn3jcmNH53LbgF6IKRwmrMywqDrg4SiSNApEefkAbPSIzN39FC8VsxPg== + +"@esbuild/linux-ppc64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.21.1.tgz#2aafcfe2826c7d5d2e3c41eb8934e6368a7cada5" + integrity sha512-bw7bcQ+270IOzDV4mcsKAnDtAFqKO0jVv3IgRSd8iM0ac3L8amvCrujRVt1ajBTJcpDaFhIX+lCNRKteoDSLig== + +"@esbuild/linux-riscv64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.21.1.tgz#481ceaf5939d14fb25da62a385b5e6c2096a3370" + integrity sha512-ARmDRNkcOGOm1AqUBSwRVDfDeD9hGYRfkudP2QdoonBz1ucWVnfBPfy7H4JPI14eYtZruRSczJxyu7SRYDVOcg== + +"@esbuild/linux-s390x@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.21.1.tgz#e25b97005e4c82540d1bc7af88e333fb55142570" + integrity sha512-o73TcUNMuoTZlhwFdsgr8SfQtmMV58sbgq6gQq9G1xUiYnHMTmJbwq65RzMx89l0iya69lR4bxBgtWiiOyDQZA== + +"@esbuild/linux-x64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.21.1.tgz#a05a61d0a0cbb03baa6db12cd8164c1e5265ffb2" + integrity sha512-da4/1mBJwwgJkbj4fMH7SOXq2zapgTo0LKXX1VUZ0Dxr+e8N0WbS80nSZ5+zf3lvpf8qxrkZdqkOqFfm57gXwA== + +"@esbuild/netbsd-x64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.21.1.tgz#e298f854e8999563f2e4668bd542678c46be4b53" + integrity sha512-CPWs0HTFe5woTJN5eKPvgraUoRHrCtzlYIAv9wBC+FAyagBSaf+UdZrjwYyTGnwPGkThV4OCI7XibZOnPvONVw== + +"@esbuild/openbsd-x64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.21.1.tgz#640d34de1e3c6bc3ff64e0379aae00ede3608f14" + integrity sha512-xxhTm5QtzNLc24R0hEkcH+zCx/o49AsdFZ0Cy5zSd/5tOj4X2g3/2AJB625NoadUuc4A8B3TenLJoYdWYOYCew== + +"@esbuild/sunos-x64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.21.1.tgz#f53cb1cdcbf05b3320e147ddb85ec2b1cf2b6cfc" + integrity sha512-CWibXszpWys1pYmbr9UiKAkX6x+Sxw8HWtw1dRESK1dLW5fFJ6rMDVw0o8MbadusvVQx1a8xuOxnHXT941Hp1A== + +"@esbuild/win32-arm64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.21.1.tgz#df4f44f9b4fec9598c0ec2c34fec9c568c8ab85d" + integrity sha512-jb5B4k+xkytGbGUS4T+Z89cQJ9DJ4lozGRSV+hhfmCPpfJ3880O31Q1srPCimm+V6UCbnigqD10EgDNgjvjerQ== + +"@esbuild/win32-ia32@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.21.1.tgz#a57edbd9905db9f957327ae0facfbf406a80a4e4" + integrity sha512-PgyFvjJhXqHn1uxPhyN1wZ6dIomKjiLUQh1LjFvjiV1JmnkZ/oMPrfeEAZg5R/1ftz4LZWZr02kefNIQ5SKREQ== + +"@esbuild/win32-x64@0.21.1": + version "0.21.1" + resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.21.1.tgz#eb86553d90e86a8c174b96650fdb4c60f2de16a7" + integrity sha512-W9NttRZQR5ehAiqHGDnvfDaGmQOm6Fi4vSlce8mjM75x//XKuVAByohlEX6N17yZnVXxQFuh4fDRunP8ca6bfA== + +"@exodus/schemasafe@^1.0.0-rc.2": + version "1.3.0" + resolved "https://registry.yarnpkg.com/@exodus/schemasafe/-/schemasafe-1.3.0.tgz#731656abe21e8e769a7f70a4d833e6312fe59b7f" + integrity sha512-5Aap/GaRupgNx/feGBwLLTVv8OQFfv3pq2lPRzPg9R+IOBnDgghTGW7l7EuVXOvg5cc/xSAlRW8rBrjIC3Nvqw== + +"@fastify/busboy@^2.0.0": + version "2.1.1" + resolved "https://registry.yarnpkg.com/@fastify/busboy/-/busboy-2.1.1.tgz#b9da6a878a371829a0502c9b6c1c143ef6663f4d" + integrity sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA== + +"@jsdevtools/ono@^7.1.3": + version "7.1.3" + resolved "https://registry.yarnpkg.com/@jsdevtools/ono/-/ono-7.1.3.tgz#9df03bbd7c696a5c58885c34aa06da41c8543796" + integrity sha512-4JQNk+3mVzK3xh2rqd6RB4J46qUR19azEHBneZyTZM+c456qOrbbM/5xcR8huNCCcbVt7+UmizG6GuUvPvKUYg== + +"@kahirokunn/oazapfts-patched@^0.0.1": + version "0.0.1" + resolved "https://registry.yarnpkg.com/@kahirokunn/oazapfts-patched/-/oazapfts-patched-0.0.1.tgz#b045605c466cdc99451175072d1af33bd22dca49" + integrity sha512-lR6kPSk5KqXVRTYZkaJmExq2k5UEPGLJyCFaZBUzETGCw2oi6ASAzcFr1vLF5wnBW6nHd2kPYcqCuLc+Ckd2jQ== + dependencies: + "@apidevtools/swagger-parser" "^10.1.0" + lodash "^4.17.21" + minimist "^1.2.8" + swagger2openapi "^7.0.8" + typescript "^5.2.2" + +"@kubekit/client@0.0.23": + version "0.0.23" + resolved "https://registry.yarnpkg.com/@kubekit/client/-/client-0.0.23.tgz#692a2d7c27b0cdb4fff5dd062326572635510657" + integrity sha512-XQB7WiXOFDlRKViph6WehdjmuLduE16e8P9jHs003PZp8lvGeRZ0OtAvlBF4adFM1y9qw1PJ+IsjbRpR9vu9yw== + dependencies: + "@kubernetes/client-node" "^0.20.0" + undici "^5.28.3" + +"@kubekit/codegen@^0.0.19": + version "0.0.19" + resolved "https://registry.yarnpkg.com/@kubekit/codegen/-/codegen-0.0.19.tgz#113e055209d6b5aa2e183b45bedd62336801bdf1" + integrity sha512-Mem+py8obQIQQWNs0agLK3H6Q042hc4vcnX5CG1XSI0U1piUUpq8pq6MSpcqenrPCMf8NqT2kqEJ+qz2tjSc3Q== + dependencies: + "@apidevtools/swagger-parser" "^10.0.2" + "@kahirokunn/oazapfts-patched" "^0.0.1" + commander "^6.2.0" + deepmerge "^4.3.1" + prettier "^2.8.8" + semver "^7.3.5" + swagger2openapi "^7.0.4" + +"@kubekit/sync@^0.0.21": + version "0.0.21" + resolved "https://registry.yarnpkg.com/@kubekit/sync/-/sync-0.0.21.tgz#7048fb920004e8a09d942375f99edc3e2aa8ae6c" + integrity sha512-+UZ7dG/aWl883O1m9KaboU1B7uJCIVrxWA2dR0qgevVqWJ9I4oKog2zKuCA5Jg35+mW3uj8Fdyr0vE4beG18ow== + dependencies: + ts-retry-promise "^0.8.0" + +"@kubernetes/client-node@^0.20.0": + version "0.20.0" + resolved "https://registry.yarnpkg.com/@kubernetes/client-node/-/client-node-0.20.0.tgz#4447ae27fd6eef3d4830a5a039f3b84ffd5c5913" + integrity sha512-xxlv5GLX4FVR/dDKEsmi4SPeuB49aRc35stndyxcC73XnUEEwF39vXbROpHOirmDse8WE9vxOjABnSVS+jb7EA== + dependencies: + "@types/js-yaml" "^4.0.1" + "@types/node" "^20.1.1" + "@types/request" "^2.47.1" + "@types/ws" "^8.5.3" + byline "^5.0.0" + isomorphic-ws "^5.0.0" + js-yaml "^4.1.0" + jsonpath-plus "^7.2.0" + request "^2.88.0" + rfc4648 "^1.3.0" + stream-buffers "^3.0.2" + tar "^6.1.11" + tslib "^2.4.1" + ws "^8.11.0" + optionalDependencies: + openid-client "^5.3.0" + +"@types/caseless@*": + version "0.12.5" + resolved "https://registry.yarnpkg.com/@types/caseless/-/caseless-0.12.5.tgz#db9468cb1b1b5a925b8f34822f1669df0c5472f5" + integrity sha512-hWtVTC2q7hc7xZ/RLbxapMvDMgUnDvKvMOpKal4DrMyfGBUfB1oKaZlIRr6mJL+If3bAP6sV/QneGzF6tJjZDg== + +"@types/js-yaml@^4.0.1": + version "4.0.9" + resolved "https://registry.yarnpkg.com/@types/js-yaml/-/js-yaml-4.0.9.tgz#cd82382c4f902fed9691a2ed79ec68c5898af4c2" + integrity sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg== + +"@types/lodash.merge@^4.6.9": + version "4.6.9" + resolved "https://registry.yarnpkg.com/@types/lodash.merge/-/lodash.merge-4.6.9.tgz#93e94796997ed9a3ebe9ccf071ccaec4c6bc8fb8" + integrity sha512-23sHDPmzd59kUgWyKGiOMO2Qb9YtqRO/x4IhkgNUiPQ1+5MUVqi6bCZeq9nBJ17msjIMbEIO5u+XW4Kz6aGUhQ== + dependencies: + "@types/lodash" "*" + +"@types/lodash@*": + version "4.17.1" + resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.17.1.tgz#0fabfcf2f2127ef73b119d98452bd317c4a17eb8" + integrity sha512-X+2qazGS3jxLAIz5JDXDzglAF3KpijdhFxlf/V1+hEsOUc+HnWi81L/uv/EvGuV90WY+7mPGFCUDGfQC3Gj95Q== + +"@types/node@*", "@types/node@^20.1.1": + version "20.12.10" + resolved "https://registry.yarnpkg.com/@types/node/-/node-20.12.10.tgz#8f0c3f12b0f075eee1fe20c1afb417e9765bef76" + integrity sha512-Eem5pH9pmWBHoGAT8Dr5fdc5rYA+4NAovdM4EktRPVAAiJhmWWfQrA0cFhAbOsQdSfIHjAud6YdkbL69+zSKjw== + dependencies: + undici-types "~5.26.4" + +"@types/node@^20.11.30": + version "20.11.30" + resolved "https://registry.yarnpkg.com/@types/node/-/node-20.11.30.tgz#9c33467fc23167a347e73834f788f4b9f399d66f" + integrity sha512-dHM6ZxwlmuZaRmUPfv1p+KrdD1Dci04FbdEm/9wEMouFqxYoFl5aMkt0VMAUtYRQDyYvD41WJLukhq/ha3YuTw== + dependencies: + undici-types "~5.26.4" + +"@types/request@^2.47.1": + version "2.48.12" + resolved "https://registry.yarnpkg.com/@types/request/-/request-2.48.12.tgz#0f590f615a10f87da18e9790ac94c29ec4c5ef30" + integrity sha512-G3sY+NpsA9jnwm0ixhAFQSJ3Q9JkpLZpJbI3GMv0mIAT0y3mRabYeINzal5WOChIiaTEGQYlHOKgkaM9EisWHw== + dependencies: + "@types/caseless" "*" + "@types/node" "*" + "@types/tough-cookie" "*" + form-data "^2.5.0" + +"@types/tough-cookie@*": + version "4.0.5" + resolved "https://registry.yarnpkg.com/@types/tough-cookie/-/tough-cookie-4.0.5.tgz#cb6e2a691b70cb177c6e3ae9c1d2e8b2ea8cd304" + integrity sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA== + +"@types/ws@^8.5.3": + version "8.5.10" + resolved "https://registry.yarnpkg.com/@types/ws/-/ws-8.5.10.tgz#4acfb517970853fa6574a3a6886791d04a396787" + integrity sha512-vmQSUcfalpIq0R9q7uTo2lXs6eGIpt9wtnLdMv9LVpIjCA/+ufZRozlVoVelIYixx1ugCBKDhn89vnsEGOCx9A== + dependencies: + "@types/node" "*" + +ajv-draft-04@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/ajv-draft-04/-/ajv-draft-04-1.0.0.tgz#3b64761b268ba0b9e668f0b41ba53fce0ad77fc8" + integrity sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw== + +ajv@^6.12.3: + version "6.12.6" + resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4" + integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== + dependencies: + fast-deep-equal "^3.1.1" + fast-json-stable-stringify "^2.0.0" + json-schema-traverse "^0.4.1" + uri-js "^4.2.2" + +ajv@^8.6.3: + version "8.13.0" + resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.13.0.tgz#a3939eaec9fb80d217ddf0c3376948c023f28c91" + integrity sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA== + dependencies: + fast-deep-equal "^3.1.3" + json-schema-traverse "^1.0.0" + require-from-string "^2.0.2" + uri-js "^4.4.1" + +ansi-regex@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304" + integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== + +ansi-styles@^4.0.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" + integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== + dependencies: + color-convert "^2.0.1" + +argparse@^1.0.7: + version "1.0.10" + resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911" + integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg== + dependencies: + sprintf-js "~1.0.2" + +argparse@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38" + integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q== + +asn1@~0.2.3: + version "0.2.6" + resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.6.tgz#0d3a7bb6e64e02a90c0303b31f292868ea09a08d" + integrity sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ== + dependencies: + safer-buffer "~2.1.0" + +assert-plus@1.0.0, assert-plus@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525" + integrity sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw== + +asynckit@^0.4.0: + version "0.4.0" + resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79" + integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q== + +aws-sign2@~0.7.0: + version "0.7.0" + resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8" + integrity sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA== + +aws4@^1.8.0: + version "1.12.0" + resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.12.0.tgz#ce1c9d143389679e253b314241ea9aa5cec980d3" + integrity sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg== + +bcrypt-pbkdf@^1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz#a4301d389b6a43f9b67ff3ca11a3f6637e360e9e" + integrity sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w== + dependencies: + tweetnacl "^0.14.3" + +buffer-from@^1.0.0: + version "1.1.2" + resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5" + integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ== + +byline@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/byline/-/byline-5.0.0.tgz#741c5216468eadc457b03410118ad77de8c1ddb1" + integrity sha512-s6webAy+R4SR8XVuJWt2V2rGvhnrhxN+9S15GNuTK3wKPOXFF6RNc+8ug2XhH+2s4f+uudG4kUVYmYOQWL2g0Q== + +call-me-maybe@^1.0.1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/call-me-maybe/-/call-me-maybe-1.0.2.tgz#03f964f19522ba643b1b0693acb9152fe2074baa" + integrity sha512-HpX65o1Hnr9HH25ojC1YGs7HCQLq0GCOibSaWER0eNpgJ/Z1MZv2mTc7+xh6WOPxbRVcmgbv4hGU+uSQ/2xFZQ== + +caseless@~0.12.0: + version "0.12.0" + resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc" + integrity sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw== + +chownr@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/chownr/-/chownr-2.0.0.tgz#15bfbe53d2eab4cf70f18a8cd68ebe5b3cb1dece" + integrity sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ== + +cliui@^8.0.1: + version "8.0.1" + resolved "https://registry.yarnpkg.com/cliui/-/cliui-8.0.1.tgz#0c04b075db02cbfe60dc8e6cf2f5486b1a3608aa" + integrity sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ== + dependencies: + string-width "^4.2.0" + strip-ansi "^6.0.1" + wrap-ansi "^7.0.0" + +color-convert@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3" + integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== + dependencies: + color-name "~1.1.4" + +color-name@~1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" + integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== + +combined-stream@^1.0.6, combined-stream@~1.0.6: + version "1.0.8" + resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f" + integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg== + dependencies: + delayed-stream "~1.0.0" + +commander@^6.2.0: + version "6.2.1" + resolved "https://registry.yarnpkg.com/commander/-/commander-6.2.1.tgz#0792eb682dfbc325999bb2b84fddddba110ac73c" + integrity sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA== + +core-util-is@1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7" + integrity sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ== + +dashdash@^1.12.0: + version "1.14.1" + resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0" + integrity sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g== + dependencies: + assert-plus "^1.0.0" + +deepmerge@^4.3.1: + version "4.3.1" + resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.3.1.tgz#44b5f2147cd3b00d4b56137685966f26fd25dd4a" + integrity sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A== + +delayed-stream@~1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619" + integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ== + +ecc-jsbn@~0.1.1: + version "0.1.2" + resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz#3a83a904e54353287874c564b7549386849a98c9" + integrity sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw== + dependencies: + jsbn "~0.1.0" + safer-buffer "^2.1.0" + +emoji-regex@^8.0.0: + version "8.0.0" + resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" + integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== + +es6-promise@^3.2.1: + version "3.3.1" + resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-3.3.1.tgz#a08cdde84ccdbf34d027a1451bc91d4bcd28a613" + integrity sha512-SOp9Phqvqn7jtEUxPWdWfWoLmyt2VaJ6MpvP9Comy1MceMXqE6bxvaTu4iaxpYYPzhny28Lc+M87/c2cPK6lDg== + +esbuild-runner@^2.2.2: + version "2.2.2" + resolved "https://registry.yarnpkg.com/esbuild-runner/-/esbuild-runner-2.2.2.tgz#4243089f14c9690bff70beee16da3c41fd1dec50" + integrity sha512-fRFVXcmYVmSmtYm2mL8RlUASt2TDkGh3uRcvHFOKNr/T58VrfVeKD9uT9nlgxk96u0LS0ehS/GY7Da/bXWKkhw== + dependencies: + source-map-support "0.5.21" + tslib "2.4.0" + +esbuild@^0.21.1: + version "0.21.1" + resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.21.1.tgz#3d6f199f6ec849158278c6632f438463bab88c38" + integrity sha512-GPqx+FX7mdqulCeQ4TsGZQ3djBJkx5k7zBGtqt9ycVlWNg8llJ4RO9n2vciu8BN2zAEs6lPbPl0asZsAh7oWzg== + optionalDependencies: + "@esbuild/aix-ppc64" "0.21.1" + "@esbuild/android-arm" "0.21.1" + "@esbuild/android-arm64" "0.21.1" + "@esbuild/android-x64" "0.21.1" + "@esbuild/darwin-arm64" "0.21.1" + "@esbuild/darwin-x64" "0.21.1" + "@esbuild/freebsd-arm64" "0.21.1" + "@esbuild/freebsd-x64" "0.21.1" + "@esbuild/linux-arm" "0.21.1" + "@esbuild/linux-arm64" "0.21.1" + "@esbuild/linux-ia32" "0.21.1" + "@esbuild/linux-loong64" "0.21.1" + "@esbuild/linux-mips64el" "0.21.1" + "@esbuild/linux-ppc64" "0.21.1" + "@esbuild/linux-riscv64" "0.21.1" + "@esbuild/linux-s390x" "0.21.1" + "@esbuild/linux-x64" "0.21.1" + "@esbuild/netbsd-x64" "0.21.1" + "@esbuild/openbsd-x64" "0.21.1" + "@esbuild/sunos-x64" "0.21.1" + "@esbuild/win32-arm64" "0.21.1" + "@esbuild/win32-ia32" "0.21.1" + "@esbuild/win32-x64" "0.21.1" + +escalade@^3.1.1: + version "3.1.2" + resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.2.tgz#54076e9ab29ea5bf3d8f1ed62acffbb88272df27" + integrity sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA== + +esprima@^4.0.0: + version "4.0.1" + resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71" + integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== + +extend@~3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa" + integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g== + +extsprintf@1.3.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.3.0.tgz#96918440e3041a7a414f8c52e3c574eb3c3e1e05" + integrity sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g== + +extsprintf@^1.2.0: + version "1.4.1" + resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.1.tgz#8d172c064867f235c0c84a596806d279bf4bcc07" + integrity sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA== + +fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: + version "3.1.3" + resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" + integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== + +fast-json-stable-stringify@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633" + integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== + +fast-safe-stringify@^2.0.7: + version "2.1.1" + resolved "https://registry.yarnpkg.com/fast-safe-stringify/-/fast-safe-stringify-2.1.1.tgz#c406a83b6e70d9e35ce3b30a81141df30aeba884" + integrity sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA== + +forever-agent@~0.6.1: + version "0.6.1" + resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91" + integrity sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw== + +form-data@^2.5.0: + version "2.5.1" + resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.5.1.tgz#f2cbec57b5e59e23716e128fe44d4e5dd23895f4" + integrity sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.6" + mime-types "^2.1.12" + +form-data@~2.3.2: + version "2.3.3" + resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.3.3.tgz#dcce52c05f644f298c6a7ab936bd724ceffbf3a6" + integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.6" + mime-types "^2.1.12" + +fs-minipass@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-2.1.0.tgz#7f5036fdbf12c63c169190cbe4199c852271f9fb" + integrity sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg== + dependencies: + minipass "^3.0.0" + +get-caller-file@^2.0.5: + version "2.0.5" + resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e" + integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== + +getpass@^0.1.1: + version "0.1.7" + resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa" + integrity sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng== + dependencies: + assert-plus "^1.0.0" + +har-schema@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/har-schema/-/har-schema-2.0.0.tgz#a94c2224ebcac04782a0d9035521f24735b7ec92" + integrity sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q== + +har-validator@~5.1.3: + version "5.1.5" + resolved "https://registry.yarnpkg.com/har-validator/-/har-validator-5.1.5.tgz#1f0803b9f8cb20c0fa13822df1ecddb36bde1efd" + integrity sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w== + dependencies: + ajv "^6.12.3" + har-schema "^2.0.0" + +http-signature@~1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.2.0.tgz#9aecd925114772f3d95b65a60abb8f7c18fbace1" + integrity sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ== + dependencies: + assert-plus "^1.0.0" + jsprim "^1.2.2" + sshpk "^1.7.0" + +http2-client@^1.2.5: + version "1.3.5" + resolved "https://registry.yarnpkg.com/http2-client/-/http2-client-1.3.5.tgz#20c9dc909e3cc98284dd20af2432c524086df181" + integrity sha512-EC2utToWl4RKfs5zd36Mxq7nzHHBuomZboI0yYL6Y0RmBgT7Sgkq4rQ0ezFTYoIsSs7Tm9SJe+o2FcAg6GBhGA== + +is-fullwidth-code-point@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d" + integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== + +is-typedarray@~1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a" + integrity sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA== + +isomorphic-ws@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/isomorphic-ws/-/isomorphic-ws-5.0.0.tgz#e5529148912ecb9b451b46ed44d53dae1ce04bbf" + integrity sha512-muId7Zzn9ywDsyXgTIafTry2sV3nySZeUDe6YedVd1Hvuuep5AsIlqK+XefWpYTyJG5e503F2xIuT2lcU6rCSw== + +isstream@~0.1.2: + version "0.1.2" + resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a" + integrity sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g== + +jose@^4.15.5: + version "4.15.5" + resolved "https://registry.yarnpkg.com/jose/-/jose-4.15.5.tgz#6475d0f467ecd3c630a1b5dadd2735a7288df706" + integrity sha512-jc7BFxgKPKi94uOvEmzlSWFFe2+vASyXaKUpdQKatWAESU2MWjDfFf0fdfc83CDKcA5QecabZeNLyfhe3yKNkg== + +js-yaml@^3.13.1: + version "3.14.1" + resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537" + integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g== + dependencies: + argparse "^1.0.7" + esprima "^4.0.0" + +js-yaml@^4.1.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602" + integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA== + dependencies: + argparse "^2.0.1" + +jsbn@~0.1.0: + version "0.1.1" + resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513" + integrity sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg== + +json-schema-traverse@^0.4.1: + version "0.4.1" + resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660" + integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg== + +json-schema-traverse@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2" + integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug== + +json-schema@0.4.0: + version "0.4.0" + resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.4.0.tgz#f7de4cf6efab838ebaeb3236474cbba5a1930ab5" + integrity sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA== + +json-stringify-safe@~5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb" + integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA== + +jsonpath-plus@^7.2.0: + version "7.2.0" + resolved "https://registry.yarnpkg.com/jsonpath-plus/-/jsonpath-plus-7.2.0.tgz#7ad94e147b3ed42f7939c315d2b9ce490c5a3899" + integrity sha512-zBfiUPM5nD0YZSBT/o/fbCUlCcepMIdP0CJZxM1+KgA4f2T206f6VAg9e7mX35+KlMaIc5qXW34f3BnwJ3w+RA== + +jsprim@^1.2.2: + version "1.4.2" + resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.2.tgz#712c65533a15c878ba59e9ed5f0e26d5b77c5feb" + integrity sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw== + dependencies: + assert-plus "1.0.0" + extsprintf "1.3.0" + json-schema "0.4.0" + verror "1.10.0" + +lodash.merge@^4.6.2: + version "4.6.2" + resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a" + integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ== + +lodash@^4.17.21: + version "4.17.21" + resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" + integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== + +lru-cache@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94" + integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA== + dependencies: + yallist "^4.0.0" + +mime-db@1.52.0: + version "1.52.0" + resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70" + integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== + +mime-types@^2.1.12, mime-types@~2.1.19: + version "2.1.35" + resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a" + integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== + dependencies: + mime-db "1.52.0" + +minimist@^1.2.8: + version "1.2.8" + resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c" + integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== + +minipass@^3.0.0: + version "3.3.6" + resolved "https://registry.yarnpkg.com/minipass/-/minipass-3.3.6.tgz#7bba384db3a1520d18c9c0e5251c3444e95dd94a" + integrity sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw== + dependencies: + yallist "^4.0.0" + +minipass@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/minipass/-/minipass-5.0.0.tgz#3e9788ffb90b694a5d0ec94479a45b5d8738133d" + integrity sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ== + +minizlib@^2.1.1: + version "2.1.2" + resolved "https://registry.yarnpkg.com/minizlib/-/minizlib-2.1.2.tgz#e90d3466ba209b932451508a11ce3d3632145931" + integrity sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg== + dependencies: + minipass "^3.0.0" + yallist "^4.0.0" + +mkdirp@^1.0.3: + version "1.0.4" + resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e" + integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== + +node-fetch-h2@^2.3.0: + version "2.3.0" + resolved "https://registry.yarnpkg.com/node-fetch-h2/-/node-fetch-h2-2.3.0.tgz#c6188325f9bd3d834020bf0f2d6dc17ced2241ac" + integrity sha512-ofRW94Ab0T4AOh5Fk8t0h8OBWrmjb0SSB20xh1H8YnPV9EJ+f5AMoYSUQ2zgJ4Iq2HAK0I2l5/Nequ8YzFS3Hg== + dependencies: + http2-client "^1.2.5" + +node-fetch@^2.6.1: + version "2.7.0" + resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.7.0.tgz#d0f0fa6e3e2dc1d27efcd8ad99d550bda94d187d" + integrity sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A== + dependencies: + whatwg-url "^5.0.0" + +node-readfiles@^0.2.0: + version "0.2.0" + resolved "https://registry.yarnpkg.com/node-readfiles/-/node-readfiles-0.2.0.tgz#dbbd4af12134e2e635c245ef93ffcf6f60673a5d" + integrity sha512-SU00ZarexNlE4Rjdm83vglt5Y9yiQ+XI1XpflWlb7q7UTN1JUItm69xMeiQCTxtTfnzt+83T8Cx+vI2ED++VDA== + dependencies: + es6-promise "^3.2.1" + +oas-kit-common@^1.0.8: + version "1.0.8" + resolved "https://registry.yarnpkg.com/oas-kit-common/-/oas-kit-common-1.0.8.tgz#6d8cacf6e9097967a4c7ea8bcbcbd77018e1f535" + integrity sha512-pJTS2+T0oGIwgjGpw7sIRU8RQMcUoKCDWFLdBqKB2BNmGpbBMH2sdqAaOXUg8OzonZHU0L7vfJu1mJFEiYDWOQ== + dependencies: + fast-safe-stringify "^2.0.7" + +oas-linter@^3.2.2: + version "3.2.2" + resolved "https://registry.yarnpkg.com/oas-linter/-/oas-linter-3.2.2.tgz#ab6a33736313490659035ca6802dc4b35d48aa1e" + integrity sha512-KEGjPDVoU5K6swgo9hJVA/qYGlwfbFx+Kg2QB/kd7rzV5N8N5Mg6PlsoCMohVnQmo+pzJap/F610qTodKzecGQ== + dependencies: + "@exodus/schemasafe" "^1.0.0-rc.2" + should "^13.2.1" + yaml "^1.10.0" + +oas-resolver@^2.5.6: + version "2.5.6" + resolved "https://registry.yarnpkg.com/oas-resolver/-/oas-resolver-2.5.6.tgz#10430569cb7daca56115c915e611ebc5515c561b" + integrity sha512-Yx5PWQNZomfEhPPOphFbZKi9W93CocQj18NlD2Pa4GWZzdZpSJvYwoiuurRI7m3SpcChrnO08hkuQDL3FGsVFQ== + dependencies: + node-fetch-h2 "^2.3.0" + oas-kit-common "^1.0.8" + reftools "^1.1.9" + yaml "^1.10.0" + yargs "^17.0.1" + +oas-schema-walker@^1.1.5: + version "1.1.5" + resolved "https://registry.yarnpkg.com/oas-schema-walker/-/oas-schema-walker-1.1.5.tgz#74c3cd47b70ff8e0b19adada14455b5d3ac38a22" + integrity sha512-2yucenq1a9YPmeNExoUa9Qwrt9RFkjqaMAA1X+U7sbb0AqBeTIdMHky9SQQ6iN94bO5NW0W4TRYXerG+BdAvAQ== + +oas-validator@^5.0.8: + version "5.0.8" + resolved "https://registry.yarnpkg.com/oas-validator/-/oas-validator-5.0.8.tgz#387e90df7cafa2d3ffc83b5fb976052b87e73c28" + integrity sha512-cu20/HE5N5HKqVygs3dt94eYJfBi0TsZvPVXDhbXQHiEityDN+RROTleefoKRKKJ9dFAF2JBkDHgvWj0sjKGmw== + dependencies: + call-me-maybe "^1.0.1" + oas-kit-common "^1.0.8" + oas-linter "^3.2.2" + oas-resolver "^2.5.6" + oas-schema-walker "^1.1.5" + reftools "^1.1.9" + should "^13.2.1" + yaml "^1.10.0" + +oauth-sign@~0.9.0: + version "0.9.0" + resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455" + integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ== + +object-hash@^2.2.0: + version "2.2.0" + resolved "https://registry.yarnpkg.com/object-hash/-/object-hash-2.2.0.tgz#5ad518581eefc443bd763472b8ff2e9c2c0d54a5" + integrity sha512-gScRMn0bS5fH+IuwyIFgnh9zBdo4DV+6GhygmWM9HyNJSgS0hScp1f5vjtm7oIIOiT9trXrShAkLFSc2IqKNgw== + +oidc-token-hash@^5.0.3: + version "5.0.3" + resolved "https://registry.yarnpkg.com/oidc-token-hash/-/oidc-token-hash-5.0.3.tgz#9a229f0a1ce9d4fc89bcaee5478c97a889e7b7b6" + integrity sha512-IF4PcGgzAr6XXSff26Sk/+P4KZFJVuHAJZj3wgO3vX2bMdNVp/QXTP3P7CEm9V1IdG8lDLY3HhiqpsE/nOwpPw== + +openapi-types@^12.1.3: + version "12.1.3" + resolved "https://registry.yarnpkg.com/openapi-types/-/openapi-types-12.1.3.tgz#471995eb26c4b97b7bd356aacf7b91b73e777dd3" + integrity sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw== + +openid-client@^5.3.0: + version "5.6.5" + resolved "https://registry.yarnpkg.com/openid-client/-/openid-client-5.6.5.tgz#c149ad07b9c399476dc347097e297bbe288b8b00" + integrity sha512-5P4qO9nGJzB5PI0LFlhj4Dzg3m4odt0qsJTfyEtZyOlkgpILwEioOhVVJOrS1iVH494S4Ee5OCjjg6Bf5WOj3w== + dependencies: + jose "^4.15.5" + lru-cache "^6.0.0" + object-hash "^2.2.0" + oidc-token-hash "^5.0.3" + +performance-now@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b" + integrity sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow== + +prettier@^2.8.8: + version "2.8.8" + resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.8.tgz#e8c5d7e98a4305ffe3de2e1fc4aca1a71c28b1da" + integrity sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q== + +psl@^1.1.28: + version "1.9.0" + resolved "https://registry.yarnpkg.com/psl/-/psl-1.9.0.tgz#d0df2a137f00794565fcaf3b2c00cd09f8d5a5a7" + integrity sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag== + +punycode@^2.1.0, punycode@^2.1.1: + version "2.3.1" + resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.1.tgz#027422e2faec0b25e1549c3e1bd8309b9133b6e5" + integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg== + +qs@~6.5.2: + version "6.5.3" + resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.3.tgz#3aeeffc91967ef6e35c0e488ef46fb296ab76aad" + integrity sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA== + +reftools@^1.1.9: + version "1.1.9" + resolved "https://registry.yarnpkg.com/reftools/-/reftools-1.1.9.tgz#e16e19f662ccd4648605312c06d34e5da3a2b77e" + integrity sha512-OVede/NQE13xBQ+ob5CKd5KyeJYU2YInb1bmV4nRoOfquZPkAkxuOXicSe1PvqIuZZ4kD13sPKBbR7UFDmli6w== + +request@^2.88.0: + version "2.88.2" + resolved "https://registry.yarnpkg.com/request/-/request-2.88.2.tgz#d73c918731cb5a87da047e207234146f664d12b3" + integrity sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw== + dependencies: + aws-sign2 "~0.7.0" + aws4 "^1.8.0" + caseless "~0.12.0" + combined-stream "~1.0.6" + extend "~3.0.2" + forever-agent "~0.6.1" + form-data "~2.3.2" + har-validator "~5.1.3" + http-signature "~1.2.0" + is-typedarray "~1.0.0" + isstream "~0.1.2" + json-stringify-safe "~5.0.1" + mime-types "~2.1.19" + oauth-sign "~0.9.0" + performance-now "^2.1.0" + qs "~6.5.2" + safe-buffer "^5.1.2" + tough-cookie "~2.5.0" + tunnel-agent "^0.6.0" + uuid "^3.3.2" + +require-directory@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42" + integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== + +require-from-string@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909" + integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw== + +rfc4648@^1.3.0: + version "1.5.3" + resolved "https://registry.yarnpkg.com/rfc4648/-/rfc4648-1.5.3.tgz#e62b81736c10361ca614efe618a566e93d0b41c0" + integrity sha512-MjOWxM065+WswwnmNONOT+bD1nXzY9Km6u3kzvnx8F8/HXGZdz3T6e6vZJ8Q/RIMUSp/nxqjH3GwvJDy8ijeQQ== + +safe-buffer@^5.0.1, safe-buffer@^5.1.2: + version "5.2.1" + resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6" + integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== + +safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0: + version "2.1.2" + resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a" + integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg== + +semver@^7.3.5: + version "7.6.1" + resolved "https://registry.yarnpkg.com/semver/-/semver-7.6.1.tgz#60bfe090bf907a25aa8119a72b9f90ef7ca281b2" + integrity sha512-f/vbBsu+fOiYt+lmwZV0rVwJScl46HppnOA1ZvIuBWKOTlllpyJ3bfVax76/OrhCH38dyxoDIA8K7uB963IYgA== + +should-equal@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/should-equal/-/should-equal-2.0.0.tgz#6072cf83047360867e68e98b09d71143d04ee0c3" + integrity sha512-ZP36TMrK9euEuWQYBig9W55WPC7uo37qzAEmbjHz4gfyuXrEUgF8cUvQVO+w+d3OMfPvSRQJ22lSm8MQJ43LTA== + dependencies: + should-type "^1.4.0" + +should-format@^3.0.3: + version "3.0.3" + resolved "https://registry.yarnpkg.com/should-format/-/should-format-3.0.3.tgz#9bfc8f74fa39205c53d38c34d717303e277124f1" + integrity sha512-hZ58adtulAk0gKtua7QxevgUaXTTXxIi8t41L3zo9AHvjXO1/7sdLECuHeIN2SRtYXpNkmhoUP2pdeWgricQ+Q== + dependencies: + should-type "^1.3.0" + should-type-adaptors "^1.0.1" + +should-type-adaptors@^1.0.1: + version "1.1.0" + resolved "https://registry.yarnpkg.com/should-type-adaptors/-/should-type-adaptors-1.1.0.tgz#401e7f33b5533033944d5cd8bf2b65027792e27a" + integrity sha512-JA4hdoLnN+kebEp2Vs8eBe9g7uy0zbRo+RMcU0EsNy+R+k049Ki+N5tT5Jagst2g7EAja+euFuoXFCa8vIklfA== + dependencies: + should-type "^1.3.0" + should-util "^1.0.0" + +should-type@^1.3.0, should-type@^1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/should-type/-/should-type-1.4.0.tgz#0756d8ce846dfd09843a6947719dfa0d4cff5cf3" + integrity sha512-MdAsTu3n25yDbIe1NeN69G4n6mUnJGtSJHygX3+oN0ZbO3DTiATnf7XnYJdGT42JCXurTb1JI0qOBR65shvhPQ== + +should-util@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/should-util/-/should-util-1.0.1.tgz#fb0d71338f532a3a149213639e2d32cbea8bcb28" + integrity sha512-oXF8tfxx5cDk8r2kYqlkUJzZpDBqVY/II2WhvU0n9Y3XYvAYRmeaf1PvvIvTgPnv4KJ+ES5M0PyDq5Jp+Ygy2g== + +should@^13.2.1: + version "13.2.3" + resolved "https://registry.yarnpkg.com/should/-/should-13.2.3.tgz#96d8e5acf3e97b49d89b51feaa5ae8d07ef58f10" + integrity sha512-ggLesLtu2xp+ZxI+ysJTmNjh2U0TsC+rQ/pfED9bUZZ4DKefP27D+7YJVVTvKsmjLpIi9jAa7itwDGkDDmt1GQ== + dependencies: + should-equal "^2.0.0" + should-format "^3.0.3" + should-type "^1.4.0" + should-type-adaptors "^1.0.1" + should-util "^1.0.0" + +source-map-support@0.5.21: + version "0.5.21" + resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f" + integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w== + dependencies: + buffer-from "^1.0.0" + source-map "^0.6.0" + +source-map@^0.6.0: + version "0.6.1" + resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263" + integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== + +sprintf-js@~1.0.2: + version "1.0.3" + resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c" + integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g== + +sshpk@^1.7.0: + version "1.18.0" + resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.18.0.tgz#1663e55cddf4d688b86a46b77f0d5fe363aba028" + integrity sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ== + dependencies: + asn1 "~0.2.3" + assert-plus "^1.0.0" + bcrypt-pbkdf "^1.0.0" + dashdash "^1.12.0" + ecc-jsbn "~0.1.1" + getpass "^0.1.1" + jsbn "~0.1.0" + safer-buffer "^2.0.2" + tweetnacl "~0.14.0" + +stream-buffers@^3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/stream-buffers/-/stream-buffers-3.0.2.tgz#5249005a8d5c2d00b3a32e6e0a6ea209dc4f3521" + integrity sha512-DQi1h8VEBA/lURbSwFtEHnSTb9s2/pwLEaFuNhXwy1Dx3Sa0lOuYT2yNUr4/j2fs8oCAMANtrZ5OrPZtyVs3MQ== + +string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: + version "4.2.3" + resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== + dependencies: + emoji-regex "^8.0.0" + is-fullwidth-code-point "^3.0.0" + strip-ansi "^6.0.1" + +strip-ansi@^6.0.0, strip-ansi@^6.0.1: + version "6.0.1" + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== + dependencies: + ansi-regex "^5.0.1" + +swagger2openapi@^7.0.4, swagger2openapi@^7.0.8: + version "7.0.8" + resolved "https://registry.yarnpkg.com/swagger2openapi/-/swagger2openapi-7.0.8.tgz#12c88d5de776cb1cbba758994930f40ad0afac59" + integrity sha512-upi/0ZGkYgEcLeGieoz8gT74oWHA0E7JivX7aN9mAf+Tc7BQoRBvnIGHoPDw+f9TXTW4s6kGYCZJtauP6OYp7g== + dependencies: + call-me-maybe "^1.0.1" + node-fetch "^2.6.1" + node-fetch-h2 "^2.3.0" + node-readfiles "^0.2.0" + oas-kit-common "^1.0.8" + oas-resolver "^2.5.6" + oas-schema-walker "^1.1.5" + oas-validator "^5.0.8" + reftools "^1.1.9" + yaml "^1.10.0" + yargs "^17.0.1" + +tar@^6.1.11: + version "6.2.1" + resolved "https://registry.yarnpkg.com/tar/-/tar-6.2.1.tgz#717549c541bc3c2af15751bea94b1dd068d4b03a" + integrity sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A== + dependencies: + chownr "^2.0.0" + fs-minipass "^2.0.0" + minipass "^5.0.0" + minizlib "^2.1.1" + mkdirp "^1.0.3" + yallist "^4.0.0" + +tough-cookie@~2.5.0: + version "2.5.0" + resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-2.5.0.tgz#cd9fb2a0aa1d5a12b473bd9fb96fa3dcff65ade2" + integrity sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g== + dependencies: + psl "^1.1.28" + punycode "^2.1.1" + +tr46@~0.0.3: + version "0.0.3" + resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a" + integrity sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw== + +ts-retry-promise@^0.8.0: + version "0.8.0" + resolved "https://registry.yarnpkg.com/ts-retry-promise/-/ts-retry-promise-0.8.0.tgz#0a0c57b510827d5630da4b0c47f36b55b83a49e3" + integrity sha512-elI/GkojPANBikPaMWQnk4T/bOJ6tq/hqXyQRmhfC9PAD6MoHmXIXK7KilJrlpx47VAKCGcmBrTeK5dHk6YAYg== + +tslib@2.4.0: + version "2.4.0" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.4.0.tgz#7cecaa7f073ce680a05847aa77be941098f36dc3" + integrity sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ== + +tslib@^2.4.1: + version "2.6.2" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.6.2.tgz#703ac29425e7b37cd6fd456e92404d46d1f3e4ae" + integrity sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q== + +tunnel-agent@^0.6.0: + version "0.6.0" + resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd" + integrity sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w== + dependencies: + safe-buffer "^5.0.1" + +tweetnacl@^0.14.3, tweetnacl@~0.14.0: + version "0.14.5" + resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64" + integrity sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA== + +typescript@5.4.5, typescript@^5.2.2: + version "5.4.5" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.4.5.tgz#42ccef2c571fdbd0f6718b1d1f5e6e5ef006f611" + integrity sha512-vcI4UpRgg81oIRUFwR0WSIHKt11nJ7SAVlYNIu+QpqeyXP+gpQJy/Z4+F0aGxSE4MqwjyXvW/TzgkLAx2AGHwQ== + +undici-types@~5.26.4: + version "5.26.5" + resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617" + integrity sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA== + +undici@^5.28.3: + version "5.28.4" + resolved "https://registry.yarnpkg.com/undici/-/undici-5.28.4.tgz#6b280408edb6a1a604a9b20340f45b422e373068" + integrity sha512-72RFADWFqKmUb2hmmvNODKL3p9hcB6Gt2DOQMis1SEBaV6a4MH8soBvzg+95CYhCKPFedut2JY9bMfrDl9D23g== + dependencies: + "@fastify/busboy" "^2.0.0" + +uri-js@^4.2.2, uri-js@^4.4.1: + version "4.4.1" + resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e" + integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== + dependencies: + punycode "^2.1.0" + +uuid@^3.3.2: + version "3.4.0" + resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.4.0.tgz#b23e4358afa8a202fe7a100af1f5f883f02007ee" + integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A== + +verror@1.10.0: + version "1.10.0" + resolved "https://registry.yarnpkg.com/verror/-/verror-1.10.0.tgz#3a105ca17053af55d6e270c1f8288682e18da400" + integrity sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw== + dependencies: + assert-plus "^1.0.0" + core-util-is "1.0.2" + extsprintf "^1.2.0" + +webidl-conversions@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871" + integrity sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ== + +whatwg-url@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-5.0.0.tgz#966454e8765462e37644d3626f6742ce8b70965d" + integrity sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw== + dependencies: + tr46 "~0.0.3" + webidl-conversions "^3.0.0" + +wrap-ansi@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +ws@^8.11.0: + version "8.17.0" + resolved "https://registry.yarnpkg.com/ws/-/ws-8.17.0.tgz#d145d18eca2ed25aaf791a183903f7be5e295fea" + integrity sha512-uJq6108EgZMAl20KagGkzCKfMEjxmKvZHG7Tlq0Z6nOky7YF7aq4mOx6xK8TJ/i1LeK4Qus7INktacctDgY8Ow== + +y18n@^5.0.5: + version "5.0.8" + resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55" + integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== + +yallist@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72" + integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A== + +yaml@^1.10.0: + version "1.10.2" + resolved "https://registry.yarnpkg.com/yaml/-/yaml-1.10.2.tgz#2301c5ffbf12b467de8da2333a459e29e7920e4b" + integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg== + +yargs-parser@^21.1.1: + version "21.1.1" + resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35" + integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw== + +yargs@^17.0.1: + version "17.7.2" + resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.7.2.tgz#991df39aca675a192b816e1e0363f9d75d2aa269" + integrity sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w== + dependencies: + cliui "^8.0.1" + escalade "^3.1.1" + get-caller-file "^2.0.5" + require-directory "^2.1.1" + string-width "^4.2.3" + y18n "^5.0.5" + yargs-parser "^21.1.1"