From 835e2c2b68e143b47b586f2a95f8a0a4b708e944 Mon Sep 17 00:00:00 2001 From: suomiy Date: Tue, 25 Jun 2019 16:58:32 +0200 Subject: [PATCH 1/3] Introduce package kube-types: add generators for OpenShift and KubeVirt TypeScript definitions --- frontend/packages/kube-types/.gitignore | 1 + frontend/packages/kube-types/.tools/config.ts | 63 ++++++++ .../kube-types/.tools/generate-types.ts | 53 +++++++ .../.tools/generators/configured-generator.ts | 144 ++++++++++++++++++ .../.tools/generators/generic-generator.ts | 63 ++++++++ .../.tools/generators/openapi-generator.ts | 35 +++++ .../packages/kube-types/.tools/utils/index.ts | 30 ++++ frontend/packages/kube-types/package.json | 22 +++ frontend/packages/kube-types/tsconfig.json | 28 ++++ frontend/yarn.lock | 58 +++++++ 10 files changed, 497 insertions(+) create mode 100644 frontend/packages/kube-types/.gitignore create mode 100644 frontend/packages/kube-types/.tools/config.ts create mode 100644 frontend/packages/kube-types/.tools/generate-types.ts create mode 100644 frontend/packages/kube-types/.tools/generators/configured-generator.ts create mode 100644 frontend/packages/kube-types/.tools/generators/generic-generator.ts create mode 100644 frontend/packages/kube-types/.tools/generators/openapi-generator.ts create mode 100644 frontend/packages/kube-types/.tools/utils/index.ts create mode 100644 frontend/packages/kube-types/package.json create mode 100644 frontend/packages/kube-types/tsconfig.json diff --git a/frontend/packages/kube-types/.gitignore b/frontend/packages/kube-types/.gitignore new file mode 100644 index 00000000000..3fec32c8427 --- /dev/null +++ b/frontend/packages/kube-types/.gitignore @@ -0,0 +1 @@ +tmp/ diff --git a/frontend/packages/kube-types/.tools/config.ts b/frontend/packages/kube-types/.tools/config.ts new file mode 100644 index 00000000000..7df66437a2c --- /dev/null +++ b/frontend/packages/kube-types/.tools/config.ts @@ -0,0 +1,63 @@ +import * as process from 'process'; + +export const TEMP_DIR = 'tmp'; +export const SRC_DIR = 'src'; + +export const buildTempPath = (...segments) => [TEMP_DIR, ...segments].join('/'); +export const buildSrcPath = (...segments) => [SRC_DIR, ...segments].join('/'); + +const OPENSHIFT_PREFIX = 'OS'; + +export type Config = { + name: string; + url: string; + replaceMapping?: { [key: string]: string }; + dateAsString?: boolean; +}; + +export const getOpenshiftConfig = (): Config => ({ + name: 'openshift', + url: + process.env.OPENSHIFT_API_SPEC_URL || + 'https://raw.githubusercontent.com/openshift/origin/master/api/swagger-spec/openshift-openapi-spec.json', + dateAsString: true, + replaceMapping: { + ComGithubOpenshiftApiApps: OPENSHIFT_PREFIX, + ComGithubOpenshiftApiAuthorization: OPENSHIFT_PREFIX, + ComGithubOpenshiftApiBuild: OPENSHIFT_PREFIX, + ComGithubOpenshiftApiImage: OPENSHIFT_PREFIX, + ComGithubOpenshiftApiNetwork: OPENSHIFT_PREFIX, + ComGithubOpenshiftApiOauth: OPENSHIFT_PREFIX, + ComGithubOpenshiftApiProject: '', + ComGithubOpenshiftApiQuota: OPENSHIFT_PREFIX, + ComGithubOpenshiftApiRoute: '', + ComGithubOpenshiftApiSecurity: OPENSHIFT_PREFIX, + ComGithubOpenshiftApiTemplate: '', + ComGithubOpenshiftApiUser: OPENSHIFT_PREFIX, + IoK8sApiAdmissionregistration: '', + IoK8sApiApps: '', + IoK8sApiAuthentication: '', + IoK8sApiAuthorization: '', + IoK8sApiAutoscaling: '', + IoK8sApiBatch: '', + IoK8sApiCertificates: '', + IoK8sApiCore: '', + IoK8sApiEvents: '', + IoK8sApiExtensions: 'Extensions', + IoK8sApimachineryPkgApisMeta: '', + IoK8sApiNetworking: '', + IoK8sApiPolicy: '', + IoK8sApiRbac: '', + IoK8sApiScheduling: '', + IoK8sApiStorage: '', + IoK8sKubeAggregatorPkgApisApiregistration: 'APIRegistration', + }, +}); + +export const getKubevirtConfig = (): Config => ({ + name: 'kubevirt', + url: + process.env.KUBEVIRT_API_SPEC_URL || + 'https://raw.githubusercontent.com/kubevirt/kubevirt/master/api/openapi-spec/swagger.json', + dateAsString: true, +}); diff --git a/frontend/packages/kube-types/.tools/generate-types.ts b/frontend/packages/kube-types/.tools/generate-types.ts new file mode 100644 index 00000000000..bdeac4d3703 --- /dev/null +++ b/frontend/packages/kube-types/.tools/generate-types.ts @@ -0,0 +1,53 @@ +/* eslint-disable no-console */ +import { removeSync, emptyDirSync, ensureDirSync } from 'fs-extra'; +import * as process from 'process'; +import { generateAndMapTypes } from './generators/configured-generator'; +import { getKubevirtConfig, getOpenshiftConfig, SRC_DIR, TEMP_DIR } from './config'; + +type Options = { + openshift: boolean, + kubevirt: boolean, +} + +const getOptions = (): Options => { + const argsSet = new Set(process.argv); + const options = { + openshift: false, + kubevirt: false, + }; + + if(argsSet.has('all')){ + Object.keys(options).forEach( key => { + options[key] = true; + }); + }else { + options.openshift = argsSet.has('openshift'); + options.kubevirt = argsSet.has('kubevirt'); + } + return options; +}; + +const generate = async (options: Options) => { + let exitCode = 0; + try { + emptyDirSync(TEMP_DIR); + ensureDirSync(SRC_DIR); + + if(options.openshift){ + await generateAndMapTypes(getOpenshiftConfig()); + } + if(options.kubevirt){ + await generateAndMapTypes(getKubevirtConfig()); + } + + } catch (e) { + console.error('ERROR: kube-types package in inconsistent state (please revert the changes)'); + console.error(e); + exitCode = 1; + } finally { + removeSync(TEMP_DIR); + } + return exitCode; +}; + +generate(getOptions()).then( exitCode => process.exit(exitCode)); diff --git a/frontend/packages/kube-types/.tools/generators/configured-generator.ts b/frontend/packages/kube-types/.tools/generators/configured-generator.ts new file mode 100644 index 00000000000..32e2b4b3ca5 --- /dev/null +++ b/frontend/packages/kube-types/.tools/generators/configured-generator.ts @@ -0,0 +1,144 @@ +import { FileType, generateTypes } from './generic-generator'; +import { Config } from '../config'; + +const filterStartRegex = /^(import|export function|})/; + +const fromToJSONRegex = /.*(FromJSON|ToJSON)/; + +const thisFolderImportEndRegexOneLine = /from '\.\/?';$/; +const dateRegex = /(.*[^A-Za-z0-9])(Date)([^A-Za-z0-9].*)/; + +const resolveMappings = (line, replaceMappingsRegex, replaceMapping) => { + let result = line; + const possibleMapping = replaceMappingsRegex && replaceMapping && replaceMappingsRegex.exec(line); + if (possibleMapping && possibleMapping[1]) { + possibleMapping.forEach((value, index) => { + if (index !== 0) { + result = result.replace(value, replaceMapping[value]); + } + }); + } + return result; +}; + +const resolveDate = (line) => { + const possibleDate = dateRegex.exec(line); + if (possibleDate && possibleDate.length === 4) { + return `${possibleDate[1]}string${possibleDate[3]}`; + } + return line; +}; + +const getImports = (line) => { + const start = line.indexOf('{'); + const end = line.indexOf('}'); + + return line + .substring(start < 0 ? 0 : start + 1, end < 0 ? line.length : end) + .split(',') + .map((s) => s.trim()) + .filter((s) => s); +}; + +/** + * - removes global functions (..FromJSON(), ..toJSON()) + * - removes all imports (e.g. runtime folder) except the ones from this folder + * - reorganizes imports to prevent circular dependencies + */ + +export const processFile = ( + { content, filename }: FileType, + { replaceMapping, dateAsString }: Config, +) => { + const replaceMappingsRegex = + replaceMapping && RegExp(`(${Object.keys(replaceMapping).join('|')})`); + + let isInsideGlobalFunction = false; + let isInsideImport = false; + + let firstImportLineNumber = null; + + const filesToImport = []; + const filesToImportBuffer = []; + + const resultContent = content + .split('\n') + .map((line, index) => { + const possibleIlegalStart = filterStartRegex.exec(line); + switch (possibleIlegalStart && possibleIlegalStart[1]) { + case 'import': + if (firstImportLineNumber == null) { + firstImportLineNumber = index; + } + + if (line.endsWith(';')) { + if (line.match(thisFolderImportEndRegexOneLine)) { + filesToImport.push(...getImports(line)); + } + return null; + } + isInsideImport = true; + return null; + case 'export function': + isInsideGlobalFunction = true; + return null; + case '}': + if (isInsideGlobalFunction) { + isInsideGlobalFunction = false; + return null; + } + if (isInsideImport) { + if (line.match(thisFolderImportEndRegexOneLine)) { + filesToImport.push(...filesToImportBuffer); + } + filesToImportBuffer.length = 0; + isInsideImport = false; + return null; + } + break; + default: + break; + } + + if (isInsideGlobalFunction) { + return null; + } + + if (isInsideImport) { + filesToImportBuffer.push(...getImports(line)); + return null; + } + + const result = resolveMappings(line, replaceMappingsRegex, replaceMapping); + + return dateAsString ? resolveDate(result) : result; + }) + .filter((line) => line != null); + + const resolvedImports = filesToImport + .filter((imp) => !fromToJSONRegex.exec(imp)) + .map((imp) => { + const mappedImport = resolveMappings(imp, replaceMappingsRegex, replaceMapping); + return `import { ${mappedImport} } from './${mappedImport}';`; + }); + + resultContent.splice(firstImportLineNumber, 0, ...resolvedImports); + + return { + content: resultContent.join('\n'), + filename: resolveMappings(filename, replaceMappingsRegex, replaceMapping), + }; +}; + +export const processAPIObject = (APIObj) => { + // to prevent error: "Multiple schemas found in content, returning only the first one" + APIObj.paths = {}; + return APIObj; +}; + +export const generateAndMapTypes = async (config: Config) => + generateTypes({ + config, + processAPIObject, + processFile: (file) => processFile(file, config), + }); diff --git a/frontend/packages/kube-types/.tools/generators/generic-generator.ts b/frontend/packages/kube-types/.tools/generators/generic-generator.ts new file mode 100644 index 00000000000..3d9a1976b27 --- /dev/null +++ b/frontend/packages/kube-types/.tools/generators/generic-generator.ts @@ -0,0 +1,63 @@ +/* eslint-disable no-console */ +import { emptyDirSync, moveSync } from 'fs-extra'; +import * as fs from 'fs'; +import { download } from '../utils'; +import { openapiGenerator } from './openapi-generator'; +import { buildSrcPath, buildTempPath, Config } from '../config'; + +const GENERATED = 'generated'; + +export type FileType = { + content: string; + filename: string; +}; + +const checkFileDoesNotExist = (filename) => { + if (fs.existsSync(filename)) { + throw new Error( + `Not unique filename (${filename})! (Maybe wrong package name mapping/elimination?)`, + ); + } +}; + +export const generateTypes = async ({ + config: { name, url }, + processAPIObject, + processFile, +}: { + config: Config; + processAPIObject?: Function; + processFile?: (a: FileType) => FileType; +}) => { + const openAPIObject: any = await download(url); + const generateFrom = processAPIObject ? processAPIObject(openAPIObject) : openAPIObject; + + const apiFilename = buildTempPath(name, `${name}-types.json`); + const generatedDir = buildTempPath(name, GENERATED); + + emptyDirSync(generatedDir); + fs.writeFileSync(apiFilename, JSON.stringify(generateFrom)); + await openapiGenerator(apiFilename, generatedDir); + + // copy files to src directory + emptyDirSync(buildSrcPath(name)); + + fs.readdirSync(buildTempPath(name, GENERATED, 'models')).forEach((filename) => { + const relativeTmpPathToFile = buildTempPath(name, GENERATED, 'models', filename); + if (processFile) { + const readContent = fs.readFileSync(relativeTmpPathToFile, 'utf8'); + const { content: resultContent, filename: resultFilename } = processFile({ + content: readContent, + filename, + }); + + const resultFullFilename = buildSrcPath(name, resultFilename); + checkFileDoesNotExist(resultFullFilename); + fs.writeFileSync(resultFullFilename, resultContent); + } else { + const resultFullFilename = buildSrcPath(name, filename); + checkFileDoesNotExist(resultFullFilename); + moveSync(relativeTmpPathToFile, resultFullFilename); + } + }); +}; diff --git a/frontend/packages/kube-types/.tools/generators/openapi-generator.ts b/frontend/packages/kube-types/.tools/generators/openapi-generator.ts new file mode 100644 index 00000000000..d594f5fdbbe --- /dev/null +++ b/frontend/packages/kube-types/.tools/generators/openapi-generator.ts @@ -0,0 +1,35 @@ +/* eslint-disable no-console */ +import * as process from 'process'; +import { spawn } from 'child_process'; + +export const openapiGenerator = async (input, outputFolder) => { + return new Promise((resolve, reject) => { + const genCommand = 'node_modules/.bin/openapi-generator'; + const genArgs = [ + 'generate', + '-Dmodels ', + '-DsupportingFiles ', // index.js + '--generator-name', + 'typescript-fetch', + '--input-spec', + input, + '--output', + outputFolder, + ]; + + console.log(genCommand, genArgs.join(' ')); + + const genProc = spawn(genCommand, genArgs, { env: process.env }); + genProc.stdout.pipe(process.stdout); + genProc.stderr.on('data', (errData) => console.error(String(errData))); + + genProc.on('close', (code) => { + if (code === 0) { + resolve(code); + } else { + console.error(`openapi-generator exited with code ${code}`); + reject(code); + } + }); + }); +}; diff --git a/frontend/packages/kube-types/.tools/utils/index.ts b/frontend/packages/kube-types/.tools/utils/index.ts new file mode 100644 index 00000000000..972771b66bd --- /dev/null +++ b/frontend/packages/kube-types/.tools/utils/index.ts @@ -0,0 +1,30 @@ +/* eslint-disable no-console */ +import * as https from 'https'; +import * as http from 'http'; + +const getClient = (url: string) => { + return url.startsWith('https') ? https : http; +}; + +export const download = (url: string) => { + return new Promise((resolve, reject) => { + console.log('downloading', url); + const result = []; + getClient(url) + .get(url, (response) => { + // response.setEncoding('utf8'); + if (response.statusCode < 200 || response.statusCode >= 300) { + reject(new Error(`statusCode=${response.statusCode}`)); + } + response.on('data', (chunk) => result.push(chunk)); + response.on('end', () => { + try { + resolve(JSON.parse(Buffer.concat(result).toString())); + } catch (e) { + reject(e); + } + }); + }) + .on('error', reject); + }); +}; diff --git a/frontend/packages/kube-types/package.json b/frontend/packages/kube-types/package.json new file mode 100644 index 00000000000..b324b3d0e71 --- /dev/null +++ b/frontend/packages/kube-types/package.json @@ -0,0 +1,22 @@ +{ + "name": "@console/kube-types", + "version": "0.0.0-fixed", + "description": "Kubernetes, OpenShift and KubeVirt TC types", + "private": true, + "devDependencies": { + "@types/node": "^12.0.8", + "@openapitools/openapi-generator-cli": "^0.0.14-4.0.2", + "typescript": "^3.4.4", + "ts-node": "^8.3.0", + "fs-extra": "^8.0.1" + }, + "scripts": { + "lint": "eslint --config ../../.eslintrc --ext .js,.jsx,.ts,.tsx --color . --fix", + "generate-types-openshift": "ts-node .tools/generate-types.ts openshift", + "generate-types-kubevirt": "ts-node .tools/generate-types.ts kubevirt", + "generate": "ts-node .tools/generate-types.ts all && yarn run lint" + }, + "engines": { + "node": ">=8.x" + } +} diff --git a/frontend/packages/kube-types/tsconfig.json b/frontend/packages/kube-types/tsconfig.json new file mode 100644 index 00000000000..baa20387c17 --- /dev/null +++ b/frontend/packages/kube-types/tsconfig.json @@ -0,0 +1,28 @@ +{ + "compilerOptions": { + "baseUrl": ".", + "module": "commonjs", + "moduleResolution": "node", + "outDir": "./dist/", + "target": "es5", + "lib": ["es2015", "es2016.array.include", "es2017.string"], + "allowJs": true, + "downlevelIteration": true, + "experimentalDecorators": true, + "sourceMap": true, + "noUnusedLocals": true, + "types": [ + "node", + "jest" + ] + }, + "exclude": [ + ".yarn", + "**/node_modules", + "src", + "**/__tests__" + ], + "include": [ + "./.tools/**/*.ts" + ] +} diff --git a/frontend/yarn.lock b/frontend/yarn.lock index 044a748ae75..893f431c305 100644 --- a/frontend/yarn.lock +++ b/frontend/yarn.lock @@ -129,6 +129,11 @@ resolved "https://registry.yarnpkg.com/@novnc/novnc/-/novnc-1.1.0.tgz#3827b623e9e201ee1e1c8a61d107c51cbfaeb871" integrity sha512-W90Q79EuCYT++39aT/VKGyk7hUt2gPN3rN+ifPUvY4rdjgZlfwdCg9q7yzj04hke/zgdHsbXFfyFijBvrRuU5A== +"@openapitools/openapi-generator-cli@^0.0.14-4.0.2": + version "0.0.14-4.0.2" + resolved "https://registry.yarnpkg.com/@openapitools/openapi-generator-cli/-/openapi-generator-cli-0.0.14-4.0.2.tgz#244394f7487a7744a267165828d3d5249842d2a7" + integrity sha512-x4gKaGNgG5Eqt43B4V814Bp0zUBT5h9/K0Tz4oTi5wGy+5sqU5/gElKys0jmM6wvEio2OXJm728BIFuKPuFi5w== + "@patternfly/patternfly@2.23.0": version "2.23.0" resolved "https://registry.yarnpkg.com/@patternfly/patternfly/-/patternfly-2.23.0.tgz#3351eb69a0e45aaf055940b0ad4a7fde6102a174" @@ -537,6 +542,11 @@ version "9.6.0" resolved "https://registry.yarnpkg.com/@types/node/-/node-9.6.0.tgz#d3480ee666df9784b1001a1872a2f6ccefb6c2d7" +"@types/node@^12.0.8": + version "12.0.10" + resolved "https://registry.yarnpkg.com/@types/node/-/node-12.0.10.tgz#51babf9c7deadd5343620055fc8aff7995c8b031" + integrity sha512-LcsGbPomWsad6wmMNv7nBLw7YYYyfdYcz6xryKYQhx89c3XXan+8Q6AJ43G5XDIaklaVkK3mE4fCb0SBvMiPSQ== + "@types/normalize-package-data@^2.4.0": version "2.4.0" resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.0.tgz#e486d0d97396d79beedd0a6e33f4534ff6b4973e" @@ -1150,6 +1160,11 @@ are-we-there-yet@~1.1.2: delegates "^1.0.0" readable-stream "^2.0.6" +arg@^4.1.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.0.tgz#583c518199419e0037abb74062c37f8519e575f0" + integrity sha512-ZWc51jO3qegGkVh8Hwpv636EkbesNV5ZNQPCtRa+0qytRYPEs9IYT9qITY9buezqUH5uqyzlWLcufrzU2rffdg== + argparse@^1.0.7: version "1.0.10" resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911" @@ -4006,6 +4021,11 @@ diff@^3.1.0, diff@^3.2.0, diff@^3.3.1, diff@^3.5.0: version "3.5.0" resolved "https://registry.yarnpkg.com/diff/-/diff-3.5.0.tgz#800c0dd1e0a8bfbc95835c202ad220fe317e5a12" +diff@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.1.tgz#0c667cb467ebbb5cea7f14f135cc2dba7780a8ff" + integrity sha512-s2+XdvhPCOF01LRQBC8hf4vhbVmI2CGS5aZnxLJlT5FtdhPCDFq80q++zK2KlrVorVDdL5BOGZ/VfLrVtYNF+Q== + diffie-hellman@^5.0.0: version "5.0.3" resolved "https://registry.yarnpkg.com/diffie-hellman/-/diffie-hellman-5.0.3.tgz#40e8ee98f55a2149607146921c63e1ae5f3d2875" @@ -5348,6 +5368,15 @@ fs-extra@^6.0.1: jsonfile "^4.0.0" universalify "^0.1.0" +fs-extra@^8.0.1: + version "8.0.1" + resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-8.0.1.tgz#90294081f978b1f182f347a440a209154344285b" + integrity sha512-W+XLrggcDzlle47X/XnS7FXrXu9sDo+Ze9zpndeBxdgv88FHLm1HtmkhEwavruS6koanBjp098rUpHs65EmG7A== + dependencies: + graceful-fs "^4.1.2" + jsonfile "^4.0.0" + universalify "^0.1.0" + fs-minipass@^1.2.5: version "1.2.5" resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-1.2.5.tgz#06c277218454ec288df77ada54a03b8702aacb9d" @@ -11375,6 +11404,14 @@ source-map-support@^0.5.0, source-map-support@^0.5.3: dependencies: source-map "^0.6.0" +source-map-support@^0.5.6: + version "0.5.12" + resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.12.tgz#b4f3b10d51857a5af0138d3ce8003b201613d599" + integrity sha512-4h2Pbvyy15EE02G+JOZpUCmqWJuqrs+sEkzewTm++BPi7Hvn/HwcqLAcNxYAyI0x13CpPPn+kMjl+hplXMHITQ== + dependencies: + buffer-from "^1.0.0" + source-map "^0.6.0" + source-map-support@~0.5.10: version "0.5.11" resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.11.tgz#efac2ce0800355d026326a0ca23e162aeac9a4e2" @@ -12140,6 +12177,17 @@ ts-node@5.x: source-map-support "^0.5.3" yn "^2.0.0" +ts-node@^8.3.0: + version "8.3.0" + resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-8.3.0.tgz#e4059618411371924a1fb5f3b125915f324efb57" + integrity sha512-dyNS/RqyVTDcmNM4NIBAeDMpsAdaQ+ojdf0GOLqE6nwJOgzEkdRNzJywhDfwnuvB10oa6NLVG1rUJQCpRN7qoQ== + dependencies: + arg "^4.1.0" + diff "^4.0.1" + make-error "^1.1.1" + source-map-support "^0.5.6" + yn "^3.0.0" + tsconfig-paths@^3.6.0: version "3.8.0" resolved "https://registry.yarnpkg.com/tsconfig-paths/-/tsconfig-paths-3.8.0.tgz#4e34202d5b41958f269cf56b01ed95b853d59f72" @@ -12251,6 +12299,11 @@ typescript@3.4.5: resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.4.5.tgz#2d2618d10bb566572b8d7aad5180d84257d70a99" integrity sha512-YycBxUb49UUhdNMU5aJ7z5Ej2XGmaIBL0x34vZ82fn3hGvD+bgrMrVDpatgz2f7YxUMJxMkbWxJZeAvDxVe7Vw== +typescript@^3.4.4: + version "3.5.2" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.5.2.tgz#a09e1dc69bc9551cadf17dba10ee42cf55e5d56c" + integrity sha512-7KxJovlYhTX5RaRbUdkAXN1KUZ8PwWlTzQdHV6xNqvuFOs7+WBo10TQUqT19Q/Jz2hk5v9TQDIhyLhhJY4p5AA== + ua-parser-js@^0.7.18: version "0.7.18" resolved "https://registry.yarnpkg.com/ua-parser-js/-/ua-parser-js-0.7.18.tgz#a7bfd92f56edfb117083b69e31d2aa8882d4b1ed" @@ -13492,6 +13545,11 @@ yn@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/yn/-/yn-2.0.0.tgz#e5adabc8acf408f6385fc76495684c88e6af689a" +yn@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.0.tgz#fcbe2db63610361afcc5eb9e0ac91e976d046114" + integrity sha512-kKfnnYkbTfrAdd0xICNFw7Atm8nKpLcLv9AZGEt+kczL/WQVai4e2V6ZN8U/O+iI6WrNuJjNNOyu4zfhl9D3Hg== + yup@^0.27.0: version "0.27.0" resolved "https://registry.yarnpkg.com/yup/-/yup-0.27.0.tgz#f8cb198c8e7dd2124beddc2457571329096b06e7" From 57aa864dcc731ba4d3df4d39b3c9856ac021c08c Mon Sep 17 00:00:00 2001 From: suomiy Date: Tue, 25 Jun 2019 16:59:58 +0200 Subject: [PATCH 2/3] kube-types: generate OpenShift types (v4.1.0) --- .../openshift/APIRegistrationV1APIService.ts | 54 ++ .../APIRegistrationV1APIServiceCondition.ts | 50 ++ .../APIRegistrationV1APIServiceList.ts | 47 ++ .../APIRegistrationV1APIServiceSpec.ts | 64 ++ .../APIRegistrationV1APIServiceStatus.ts | 28 + .../APIRegistrationV1ServiceReference.ts | 32 + .../APIRegistrationV1beta1APIService.ts | 54 ++ ...IRegistrationV1beta1APIServiceCondition.ts | 50 ++ .../APIRegistrationV1beta1APIServiceList.ts | 47 ++ .../APIRegistrationV1beta1APIServiceSpec.ts | 64 ++ .../APIRegistrationV1beta1APIServiceStatus.ts | 28 + .../APIRegistrationV1beta1ServiceReference.ts | 32 + .../ExtensionsV1beta1AllowedFlexVolume.ts | 26 + .../ExtensionsV1beta1AllowedHostPath.ts | 32 + .../openshift/ExtensionsV1beta1DaemonSet.ts | 54 ++ .../ExtensionsV1beta1DaemonSetCondition.ts | 50 ++ .../ExtensionsV1beta1DaemonSetList.ts | 47 ++ .../ExtensionsV1beta1DaemonSetSpec.ts | 60 ++ .../ExtensionsV1beta1DaemonSetStatus.ts | 82 +++ ...xtensionsV1beta1DaemonSetUpdateStrategy.ts | 34 + .../openshift/ExtensionsV1beta1Deployment.ts | 54 ++ .../ExtensionsV1beta1DeploymentCondition.ts | 56 ++ .../ExtensionsV1beta1DeploymentList.ts | 47 ++ .../ExtensionsV1beta1DeploymentRollback.ts | 52 ++ .../ExtensionsV1beta1DeploymentSpec.ts | 79 ++ .../ExtensionsV1beta1DeploymentStatus.ts | 70 ++ .../ExtensionsV1beta1DeploymentStrategy.ts | 34 + ...ExtensionsV1beta1FSGroupStrategyOptions.ts | 34 + .../ExtensionsV1beta1HTTPIngressPath.ts | 34 + .../ExtensionsV1beta1HTTPIngressRuleValue.ts | 28 + .../ExtensionsV1beta1HostPortRange.ts | 32 + .../src/openshift/ExtensionsV1beta1IDRange.ts | 32 + .../src/openshift/ExtensionsV1beta1IPBlock.ts | 32 + .../src/openshift/ExtensionsV1beta1Ingress.ts | 54 ++ .../ExtensionsV1beta1IngressBackend.ts | 32 + .../openshift/ExtensionsV1beta1IngressList.ts | 47 ++ .../openshift/ExtensionsV1beta1IngressRule.ts | 34 + .../openshift/ExtensionsV1beta1IngressSpec.ts | 42 ++ .../ExtensionsV1beta1IngressStatus.ts | 28 + .../openshift/ExtensionsV1beta1IngressTLS.ts | 32 + .../ExtensionsV1beta1NetworkPolicy.ts | 47 ++ ...xtensionsV1beta1NetworkPolicyEgressRule.ts | 35 + ...tensionsV1beta1NetworkPolicyIngressRule.ts | 35 + .../ExtensionsV1beta1NetworkPolicyList.ts | 47 ++ .../ExtensionsV1beta1NetworkPolicyPeer.ts | 41 ++ .../ExtensionsV1beta1NetworkPolicyPort.ts | 32 + .../ExtensionsV1beta1NetworkPolicySpec.ts | 48 ++ .../ExtensionsV1beta1PodSecurityPolicy.ts | 47 ++ .../ExtensionsV1beta1PodSecurityPolicyList.ts | 47 ++ .../ExtensionsV1beta1PodSecurityPolicySpec.ts | 148 ++++ .../openshift/ExtensionsV1beta1ReplicaSet.ts | 54 ++ .../ExtensionsV1beta1ReplicaSetCondition.ts | 50 ++ .../ExtensionsV1beta1ReplicaSetList.ts | 47 ++ .../ExtensionsV1beta1ReplicaSetSpec.ts | 47 ++ .../ExtensionsV1beta1ReplicaSetStatus.ts | 58 ++ .../ExtensionsV1beta1RollbackConfig.ts | 26 + ...ExtensionsV1beta1RollingUpdateDaemonSet.ts | 26 + ...xtensionsV1beta1RollingUpdateDeployment.ts | 32 + ...tensionsV1beta1RunAsUserStrategyOptions.ts | 34 + ...ExtensionsV1beta1SELinuxStrategyOptions.ts | 34 + .../src/openshift/ExtensionsV1beta1Scale.ts | 54 ++ .../openshift/ExtensionsV1beta1ScaleSpec.ts | 26 + .../openshift/ExtensionsV1beta1ScaleStatus.ts | 38 + ...1beta1SupplementalGroupsStrategyOptions.ts | 34 + ...IoK8sApimachineryPkgRuntimeRawExtension.ts | 26 + .../src/openshift/OSV1AllowedFlexVolume.ts | 26 + .../OSV1AppliedClusterResourceQuota.ts | 54 ++ .../OSV1AppliedClusterResourceQuotaList.ts | 47 ++ .../src/openshift/OSV1BinaryBuildSource.ts | 26 + .../openshift/OSV1BitbucketWebHookCause.ts | 34 + .../kube-types/src/openshift/OSV1Build.ts | 54 ++ .../src/openshift/OSV1BuildConfig.ts | 54 ++ .../src/openshift/OSV1BuildConfigList.ts | 47 ++ .../src/openshift/OSV1BuildConfigSpec.ts | 106 +++ .../src/openshift/OSV1BuildConfigStatus.ts | 26 + .../kube-types/src/openshift/OSV1BuildList.ts | 47 ++ .../kube-types/src/openshift/OSV1BuildLog.ts | 32 + .../src/openshift/OSV1BuildOutput.ts | 42 ++ .../src/openshift/OSV1BuildPostCommitSpec.ts | 38 + .../src/openshift/OSV1BuildRequest.ts | 101 +++ .../src/openshift/OSV1BuildSource.ts | 81 ++ .../kube-types/src/openshift/OSV1BuildSpec.ts | 88 +++ .../src/openshift/OSV1BuildStatus.ts | 96 +++ .../src/openshift/OSV1BuildStatusOutput.ts | 28 + .../src/openshift/OSV1BuildStatusOutputTo.ts | 26 + .../src/openshift/OSV1BuildStrategy.ts | 55 ++ .../src/openshift/OSV1BuildTriggerCause.ts | 62 ++ .../src/openshift/OSV1BuildTriggerPolicy.ts | 59 ++ .../src/openshift/OSV1ClusterNetwork.ts | 77 ++ .../src/openshift/OSV1ClusterNetworkEntry.ts | 32 + .../src/openshift/OSV1ClusterNetworkList.ts | 47 ++ .../src/openshift/OSV1ClusterResourceQuota.ts | 54 ++ .../openshift/OSV1ClusterResourceQuotaList.ts | 47 ++ .../OSV1ClusterResourceQuotaSelector.ts | 34 + .../openshift/OSV1ClusterResourceQuotaSpec.ts | 35 + .../OSV1ClusterResourceQuotaStatus.ts | 35 + .../src/openshift/OSV1ClusterRole.ts | 54 ++ .../src/openshift/OSV1ClusterRoleBinding.ts | 65 ++ .../openshift/OSV1ClusterRoleBindingList.ts | 47 ++ .../src/openshift/OSV1ClusterRoleList.ts | 47 ++ .../OSV1ClusterRoleScopeRestriction.ts | 38 + .../src/openshift/OSV1ConfigMapBuildSource.ts | 34 + .../src/openshift/OSV1CustomBuildStrategy.ts | 67 ++ .../OSV1CustomDeploymentStrategyParams.ts | 40 + .../src/openshift/OSV1DeploymentCause.ts | 34 + .../OSV1DeploymentCauseImageTrigger.ts | 28 + .../src/openshift/OSV1DeploymentCondition.ts | 56 ++ .../src/openshift/OSV1DeploymentConfig.ts | 54 ++ .../src/openshift/OSV1DeploymentConfigList.ts | 47 ++ .../openshift/OSV1DeploymentConfigRollback.ts | 52 ++ .../OSV1DeploymentConfigRollbackSpec.ts | 58 ++ .../src/openshift/OSV1DeploymentConfigSpec.ts | 78 ++ .../openshift/OSV1DeploymentConfigStatus.ts | 77 ++ .../src/openshift/OSV1DeploymentDetails.ts | 34 + .../src/openshift/OSV1DeploymentLog.ts | 32 + .../src/openshift/OSV1DeploymentRequest.ts | 56 ++ .../src/openshift/OSV1DeploymentStrategy.ts | 73 ++ .../OSV1DeploymentTriggerImageChangeParams.ts | 46 ++ .../openshift/OSV1DeploymentTriggerPolicy.ts | 34 + .../src/openshift/OSV1DockerBuildStrategy.ts | 72 ++ .../openshift/OSV1DockerStrategyOptions.ts | 34 + .../src/openshift/OSV1EgressNetworkPolicy.ts | 47 ++ .../openshift/OSV1EgressNetworkPolicyList.ts | 47 ++ .../openshift/OSV1EgressNetworkPolicyPeer.ts | 32 + .../openshift/OSV1EgressNetworkPolicyRule.ts | 34 + .../openshift/OSV1EgressNetworkPolicySpec.ts | 28 + .../src/openshift/OSV1ExecNewPodHook.ts | 46 ++ .../openshift/OSV1FSGroupStrategyOptions.ts | 34 + .../src/openshift/OSV1GenericWebHookCause.ts | 34 + .../src/openshift/OSV1GitBuildSource.ts | 50 ++ .../src/openshift/OSV1GitHubWebHookCause.ts | 34 + .../src/openshift/OSV1GitLabWebHookCause.ts | 34 + .../src/openshift/OSV1GitSourceRevision.ts | 46 ++ .../kube-types/src/openshift/OSV1Group.ts | 46 ++ .../kube-types/src/openshift/OSV1GroupList.ts | 47 ++ .../src/openshift/OSV1GroupRestriction.ts | 34 + .../src/openshift/OSV1HostSubnet.ts | 70 ++ .../src/openshift/OSV1HostSubnetList.ts | 47 ++ .../kube-types/src/openshift/OSV1IDRange.ts | 32 + .../kube-types/src/openshift/OSV1Identity.ts | 65 ++ .../src/openshift/OSV1IdentityList.ts | 47 ++ .../kube-types/src/openshift/OSV1Image.ts | 97 +++ .../src/openshift/OSV1ImageBlobReferences.ts | 38 + .../src/openshift/OSV1ImageChangeCause.ts | 34 + .../src/openshift/OSV1ImageChangeTrigger.ts | 40 + .../src/openshift/OSV1ImageImportSpec.ts | 55 ++ .../src/openshift/OSV1ImageImportStatus.ts | 41 ++ .../src/openshift/OSV1ImageLabel.ts | 32 + .../src/openshift/OSV1ImageLayer.ts | 38 + .../src/openshift/OSV1ImageLayerData.ts | 32 + .../kube-types/src/openshift/OSV1ImageList.ts | 47 ++ .../src/openshift/OSV1ImageLookupPolicy.ts | 26 + .../src/openshift/OSV1ImageSignature.ts | 91 +++ .../src/openshift/OSV1ImageSource.ts | 48 ++ .../src/openshift/OSV1ImageSourcePath.ts | 32 + .../src/openshift/OSV1ImageStream.ts | 54 ++ .../src/openshift/OSV1ImageStreamImage.ts | 47 ++ .../src/openshift/OSV1ImageStreamImport.ts | 54 ++ .../openshift/OSV1ImageStreamImportSpec.ts | 41 ++ .../openshift/OSV1ImageStreamImportStatus.ts | 42 ++ .../src/openshift/OSV1ImageStreamLayers.ts | 54 ++ .../src/openshift/OSV1ImageStreamList.ts | 47 ++ .../src/openshift/OSV1ImageStreamMapping.ts | 53 ++ .../src/openshift/OSV1ImageStreamSpec.ts | 41 ++ .../src/openshift/OSV1ImageStreamStatus.ts | 40 + .../src/openshift/OSV1ImageStreamTag.ts | 74 ++ .../src/openshift/OSV1ImageStreamTagList.ts | 47 ++ .../OSV1JenkinsPipelineBuildStrategy.ts | 40 + .../src/openshift/OSV1LifecycleHook.ts | 41 ++ .../OSV1LocalResourceAccessReview.ts | 88 +++ .../openshift/OSV1LocalSubjectAccessReview.ts | 106 +++ .../src/openshift/OSV1NamedTagEventList.ts | 41 ++ .../src/openshift/OSV1NetNamespace.ts | 58 ++ .../src/openshift/OSV1NetNamespaceList.ts | 47 ++ .../src/openshift/OSV1OAuthAccessToken.ts | 94 +++ .../src/openshift/OSV1OAuthAccessTokenList.ts | 47 ++ .../src/openshift/OSV1OAuthAuthorizeToken.ts | 94 +++ .../openshift/OSV1OAuthAuthorizeTokenList.ts | 47 ++ .../src/openshift/OSV1OAuthClient.ts | 89 +++ .../openshift/OSV1OAuthClientAuthorization.ts | 64 ++ .../OSV1OAuthClientAuthorizationList.ts | 47 ++ .../src/openshift/OSV1OAuthClientList.ts | 47 ++ .../openshift/OSV1PodSecurityPolicyReview.ts | 47 ++ .../OSV1PodSecurityPolicyReviewSpec.ts | 34 + .../OSV1PodSecurityPolicyReviewStatus.ts | 28 + .../OSV1PodSecurityPolicySelfSubjectReview.ts | 47 ++ ...1PodSecurityPolicySelfSubjectReviewSpec.ts | 28 + .../OSV1PodSecurityPolicySubjectReview.ts | 47 ++ .../OSV1PodSecurityPolicySubjectReviewSpec.ts | 40 + ...SV1PodSecurityPolicySubjectReviewStatus.ts | 41 ++ .../src/openshift/OSV1PolicyRule.ts | 58 ++ .../src/openshift/OSV1RangeAllocation.ts | 52 ++ .../src/openshift/OSV1RangeAllocationList.ts | 47 ++ .../OSV1RecreateDeploymentStrategyParams.ts | 46 ++ .../src/openshift/OSV1RepositoryImportSpec.ts | 48 ++ .../openshift/OSV1RepositoryImportStatus.ts | 41 ++ .../src/openshift/OSV1ResourceAccessReview.ts | 88 +++ .../OSV1ResourceQuotaStatusByNamespace.ts | 34 + .../kube-types/src/openshift/OSV1Role.ts | 47 ++ .../src/openshift/OSV1RoleBinding.ts | 65 ++ .../src/openshift/OSV1RoleBindingList.ts | 47 ++ .../openshift/OSV1RoleBindingRestriction.ts | 47 ++ .../OSV1RoleBindingRestrictionList.ts | 47 ++ .../OSV1RoleBindingRestrictionSpec.ts | 42 ++ .../kube-types/src/openshift/OSV1RoleList.ts | 47 ++ .../OSV1RollingDeploymentStrategyParams.ts | 64 ++ .../openshift/OSV1RunAsUserStrategyOptions.ts | 44 ++ .../OSV1SELinuxContextStrategyOptions.ts | 34 + .../src/openshift/OSV1ScopeRestriction.ts | 34 + .../src/openshift/OSV1SecretBuildSource.ts | 34 + .../src/openshift/OSV1SecretLocalReference.ts | 26 + .../src/openshift/OSV1SecretSpec.ts | 34 + .../OSV1SecurityContextConstraints.ts | 189 +++++ .../OSV1SecurityContextConstraintsList.ts | 47 ++ .../openshift/OSV1SelfSubjectRulesReview.ts | 47 ++ .../OSV1SelfSubjectRulesReviewSpec.ts | 26 + ...iceAccountPodSecurityPolicyReviewStatus.ts | 47 ++ .../openshift/OSV1ServiceAccountReference.ts | 32 + .../OSV1ServiceAccountRestriction.ts | 34 + .../src/openshift/OSV1SignatureCondition.ts | 56 ++ .../src/openshift/OSV1SignatureIssuer.ts | 32 + .../src/openshift/OSV1SignatureSubject.ts | 38 + .../src/openshift/OSV1SourceBuildStrategy.ts | 60 ++ .../src/openshift/OSV1SourceControlUser.ts | 32 + .../src/openshift/OSV1SourceRevision.ts | 34 + .../openshift/OSV1SourceStrategyOptions.ts | 26 + .../kube-types/src/openshift/OSV1StageInfo.ts | 46 ++ .../kube-types/src/openshift/OSV1StepInfo.ts | 38 + .../src/openshift/OSV1SubjectAccessReview.ts | 106 +++ .../src/openshift/OSV1SubjectRulesReview.ts | 47 ++ .../openshift/OSV1SubjectRulesReviewSpec.ts | 38 + .../openshift/OSV1SubjectRulesReviewStatus.ts | 34 + .../OSV1SupplementalGroupsStrategyOptions.ts | 34 + .../kube-types/src/openshift/OSV1TagEvent.ts | 44 ++ .../src/openshift/OSV1TagEventCondition.ts | 56 ++ .../src/openshift/OSV1TagImageHook.ts | 34 + .../src/openshift/OSV1TagImportPolicy.ts | 32 + .../src/openshift/OSV1TagReference.ts | 66 ++ .../src/openshift/OSV1TagReferencePolicy.ts | 26 + .../kube-types/src/openshift/OSV1User.ts | 58 ++ .../src/openshift/OSV1UserIdentityMapping.ts | 53 ++ .../kube-types/src/openshift/OSV1UserList.ts | 47 ++ .../src/openshift/OSV1UserRestriction.ts | 40 + .../src/openshift/OSV1WebHookTrigger.ts | 40 + .../kube-types/src/openshift/V1APIGroup.ts | 59 ++ .../src/openshift/V1APIGroupList.ts | 40 + .../kube-types/src/openshift/V1APIResource.ts | 74 ++ .../src/openshift/V1APIResourceList.ts | 46 ++ .../kube-types/src/openshift/V1APIVersions.ts | 46 ++ .../V1AWSElasticBlockStoreVolumeSource.ts | 44 ++ .../kube-types/src/openshift/V1Affinity.ts | 42 ++ .../src/openshift/V1AggregationRule.ts | 28 + .../src/openshift/V1AttachedVolume.ts | 32 + .../src/openshift/V1AzureDiskVolumeSource.ts | 56 ++ .../V1AzureFilePersistentVolumeSource.ts | 44 ++ .../src/openshift/V1AzureFileVolumeSource.ts | 38 + .../kube-types/src/openshift/V1Binding.ts | 47 ++ .../src/openshift/V1BrokerTemplateInstance.ts | 47 ++ .../openshift/V1BrokerTemplateInstanceList.ts | 47 ++ .../openshift/V1BrokerTemplateInstanceSpec.ts | 40 + .../openshift/V1CSIPersistentVolumeSource.ts | 70 ++ .../src/openshift/V1Capabilities.ts | 32 + .../V1CephFSPersistentVolumeSource.ts | 58 ++ .../src/openshift/V1CephFSVolumeSource.ts | 58 ++ .../V1CinderPersistentVolumeSource.ts | 46 ++ .../src/openshift/V1CinderVolumeSource.ts | 46 ++ .../src/openshift/V1ClientIPConfig.ts | 26 + .../kube-types/src/openshift/V1ClusterRole.ts | 54 ++ .../src/openshift/V1ClusterRoleBinding.ts | 54 ++ .../src/openshift/V1ClusterRoleBindingList.ts | 47 ++ .../src/openshift/V1ClusterRoleList.ts | 47 ++ .../src/openshift/V1ComponentCondition.ts | 44 ++ .../src/openshift/V1ComponentStatus.ts | 47 ++ .../src/openshift/V1ComponentStatusList.ts | 47 ++ .../kube-types/src/openshift/V1ConfigMap.ts | 52 ++ .../src/openshift/V1ConfigMapEnvSource.ts | 32 + .../src/openshift/V1ConfigMapKeySelector.ts | 38 + .../src/openshift/V1ConfigMapList.ts | 47 ++ .../openshift/V1ConfigMapNodeConfigSource.ts | 50 ++ .../src/openshift/V1ConfigMapProjection.ts | 40 + .../src/openshift/V1ConfigMapVolumeSource.ts | 46 ++ .../kube-types/src/openshift/V1Container.ts | 156 ++++ .../src/openshift/V1ContainerImage.ts | 32 + .../src/openshift/V1ContainerPort.ts | 50 ++ .../src/openshift/V1ContainerState.ts | 42 ++ .../src/openshift/V1ContainerStateRunning.ts | 26 + .../openshift/V1ContainerStateTerminated.ts | 62 ++ .../src/openshift/V1ContainerStateWaiting.ts | 32 + .../src/openshift/V1ContainerStatus.ts | 70 ++ .../src/openshift/V1ControllerRevision.ts | 53 ++ .../src/openshift/V1ControllerRevisionList.ts | 47 ++ .../V1CrossVersionObjectReference.ts | 38 + .../src/openshift/V1DaemonEndpoint.ts | 26 + .../kube-types/src/openshift/V1DaemonSet.ts | 54 ++ .../src/openshift/V1DaemonSetCondition.ts | 50 ++ .../src/openshift/V1DaemonSetList.ts | 47 ++ .../src/openshift/V1DaemonSetSpec.ts | 54 ++ .../src/openshift/V1DaemonSetStatus.ts | 82 +++ .../openshift/V1DaemonSetUpdateStrategy.ts | 34 + .../src/openshift/V1DeleteOptions.ts | 58 ++ .../kube-types/src/openshift/V1Deployment.ts | 54 ++ .../src/openshift/V1DeploymentCondition.ts | 56 ++ .../src/openshift/V1DeploymentList.ts | 47 ++ .../src/openshift/V1DeploymentSpec.ts | 72 ++ .../src/openshift/V1DeploymentStatus.ts | 70 ++ .../src/openshift/V1DeploymentStrategy.ts | 34 + .../src/openshift/V1DownwardAPIProjection.ts | 28 + .../src/openshift/V1DownwardAPIVolumeFile.ts | 47 ++ .../openshift/V1DownwardAPIVolumeSource.ts | 34 + .../src/openshift/V1EmptyDirVolumeSource.ts | 32 + .../src/openshift/V1EndpointAddress.ts | 46 ++ .../src/openshift/V1EndpointPort.ts | 38 + .../src/openshift/V1EndpointSubset.ts | 41 ++ .../kube-types/src/openshift/V1Endpoints.ts | 47 ++ .../src/openshift/V1EndpointsList.ts | 47 ++ .../src/openshift/V1EnvFromSource.ts | 41 ++ .../kube-types/src/openshift/V1EnvVar.ts | 40 + .../src/openshift/V1EnvVarSource.ts | 49 ++ .../kube-types/src/openshift/V1Event.ts | 127 ++++ .../kube-types/src/openshift/V1EventList.ts | 47 ++ .../kube-types/src/openshift/V1EventSeries.ts | 38 + .../kube-types/src/openshift/V1EventSource.ts | 32 + .../kube-types/src/openshift/V1ExecAction.ts | 26 + .../src/openshift/V1FCVolumeSource.ts | 50 ++ .../openshift/V1FlexPersistentVolumeSource.ts | 52 ++ .../src/openshift/V1FlexVolumeSource.ts | 52 ++ .../src/openshift/V1FlockerVolumeSource.ts | 32 + .../V1GCEPersistentDiskVolumeSource.ts | 44 ++ .../src/openshift/V1GitRepoVolumeSource.ts | 38 + .../src/openshift/V1GlusterfsVolumeSource.ts | 38 + .../openshift/V1GroupVersionForDiscovery.ts | 32 + .../src/openshift/V1HTTPGetAction.ts | 52 ++ .../kube-types/src/openshift/V1HTTPHeader.ts | 32 + .../kube-types/src/openshift/V1Handler.ts | 42 ++ .../openshift/V1HorizontalPodAutoscaler.ts | 54 ++ .../V1HorizontalPodAutoscalerList.ts | 47 ++ .../V1HorizontalPodAutoscalerSpec.ts | 46 ++ .../V1HorizontalPodAutoscalerStatus.ts | 50 ++ .../kube-types/src/openshift/V1HostAlias.ts | 32 + .../src/openshift/V1HostPathVolumeSource.ts | 32 + .../kube-types/src/openshift/V1IPBlock.ts | 32 + .../V1ISCSIPersistentVolumeSource.ts | 88 +++ .../src/openshift/V1ISCSIVolumeSource.ts | 88 +++ .../kube-types/src/openshift/V1Initializer.ts | 26 + .../src/openshift/V1Initializers.ts | 35 + .../kube-types/src/openshift/V1Job.ts | 54 ++ .../src/openshift/V1JobCondition.ts | 56 ++ .../kube-types/src/openshift/V1JobList.ts | 47 ++ .../kube-types/src/openshift/V1JobSpec.ts | 65 ++ .../kube-types/src/openshift/V1JobStatus.ts | 58 ++ .../kube-types/src/openshift/V1KeyToPath.ts | 38 + .../src/openshift/V1LabelSelector.ts | 34 + .../openshift/V1LabelSelectorRequirement.ts | 38 + .../kube-types/src/openshift/V1Lifecycle.ts | 34 + .../kube-types/src/openshift/V1LimitRange.ts | 47 ++ .../src/openshift/V1LimitRangeItem.ts | 56 ++ .../src/openshift/V1LimitRangeList.ts | 47 ++ .../src/openshift/V1LimitRangeSpec.ts | 28 + .../kube-types/src/openshift/V1ListMeta.ts | 38 + .../src/openshift/V1LoadBalancerIngress.ts | 32 + .../src/openshift/V1LoadBalancerStatus.ts | 28 + .../src/openshift/V1LocalObjectReference.ts | 26 + .../openshift/V1LocalSubjectAccessReview.ts | 54 ++ .../src/openshift/V1LocalVolumeSource.ts | 26 + .../src/openshift/V1NFSVolumeSource.ts | 38 + .../kube-types/src/openshift/V1Namespace.ts | 54 ++ .../src/openshift/V1NamespaceList.ts | 47 ++ .../src/openshift/V1NamespaceSpec.ts | 26 + .../src/openshift/V1NamespaceStatus.ts | 26 + .../src/openshift/V1NetworkPolicy.ts | 47 ++ .../openshift/V1NetworkPolicyEgressRule.ts | 35 + .../openshift/V1NetworkPolicyIngressRule.ts | 35 + .../src/openshift/V1NetworkPolicyList.ts | 47 ++ .../src/openshift/V1NetworkPolicyPeer.ts | 41 ++ .../src/openshift/V1NetworkPolicyPort.ts | 32 + .../src/openshift/V1NetworkPolicySpec.ts | 48 ++ .../kube-types/src/openshift/V1Node.ts | 54 ++ .../kube-types/src/openshift/V1NodeAddress.ts | 32 + .../src/openshift/V1NodeAffinity.ts | 35 + .../src/openshift/V1NodeCondition.ts | 56 ++ .../src/openshift/V1NodeConfigSource.ts | 28 + .../src/openshift/V1NodeConfigStatus.ts | 46 ++ .../src/openshift/V1NodeDaemonEndpoints.ts | 28 + .../kube-types/src/openshift/V1NodeList.ts | 47 ++ .../src/openshift/V1NodeSelector.ts | 28 + .../openshift/V1NodeSelectorRequirement.ts | 38 + .../src/openshift/V1NodeSelectorTerm.ts | 34 + .../kube-types/src/openshift/V1NodeSpec.ts | 59 ++ .../kube-types/src/openshift/V1NodeStatus.ts | 94 +++ .../src/openshift/V1NodeSystemInfo.ts | 80 ++ .../src/openshift/V1NonResourceAttributes.ts | 32 + .../src/openshift/V1NonResourceRule.ts | 32 + .../src/openshift/V1ObjectFieldSelector.ts | 32 + .../kube-types/src/openshift/V1ObjectMeta.ts | 119 +++ .../src/openshift/V1ObjectReference.ts | 62 ++ .../src/openshift/V1OwnerReference.ts | 56 ++ .../kube-types/src/openshift/V1Parameter.ts | 62 ++ .../src/openshift/V1PersistentVolume.ts | 54 ++ .../src/openshift/V1PersistentVolumeClaim.ts | 54 ++ .../V1PersistentVolumeClaimCondition.ts | 56 ++ .../openshift/V1PersistentVolumeClaimList.ts | 47 ++ .../openshift/V1PersistentVolumeClaimSpec.ts | 59 ++ .../V1PersistentVolumeClaimStatus.ts | 46 ++ .../V1PersistentVolumeClaimVolumeSource.ts | 32 + .../src/openshift/V1PersistentVolumeList.ts | 47 ++ .../src/openshift/V1PersistentVolumeSpec.ts | 225 ++++++ .../src/openshift/V1PersistentVolumeStatus.ts | 38 + .../V1PhotonPersistentDiskVolumeSource.ts | 32 + .../kube-types/src/openshift/V1Pod.ts | 54 ++ .../kube-types/src/openshift/V1PodAffinity.ts | 35 + .../src/openshift/V1PodAffinityTerm.ts | 40 + .../src/openshift/V1PodAntiAffinity.ts | 35 + .../src/openshift/V1PodCondition.ts | 56 ++ .../src/openshift/V1PodDNSConfig.ts | 40 + .../src/openshift/V1PodDNSConfigOption.ts | 32 + .../kube-types/src/openshift/V1PodList.ts | 47 ++ .../src/openshift/V1PodReadinessGate.ts | 26 + .../src/openshift/V1PodSecurityContext.ts | 65 ++ .../kube-types/src/openshift/V1PodSpec.ts | 198 +++++ .../kube-types/src/openshift/V1PodStatus.ts | 89 +++ .../kube-types/src/openshift/V1PodTemplate.ts | 47 ++ .../src/openshift/V1PodTemplateList.ts | 47 ++ .../src/openshift/V1PodTemplateSpec.ts | 35 + .../kube-types/src/openshift/V1PolicyRule.ts | 50 ++ .../src/openshift/V1PortworxVolumeSource.ts | 38 + .../src/openshift/V1Preconditions.ts | 26 + .../openshift/V1PreferredSchedulingTerm.ts | 34 + .../kube-types/src/openshift/V1Probe.ts | 72 ++ .../kube-types/src/openshift/V1Project.ts | 54 ++ .../kube-types/src/openshift/V1ProjectList.ts | 47 ++ .../src/openshift/V1ProjectRequest.ts | 52 ++ .../kube-types/src/openshift/V1ProjectSpec.ts | 26 + .../src/openshift/V1ProjectStatus.ts | 26 + .../src/openshift/V1ProjectedVolumeSource.ts | 34 + .../src/openshift/V1QuobyteVolumeSource.ts | 50 ++ .../openshift/V1RBDPersistentVolumeSource.ts | 70 ++ .../src/openshift/V1RBDVolumeSource.ts | 70 ++ .../kube-types/src/openshift/V1ReplicaSet.ts | 54 ++ .../src/openshift/V1ReplicaSetCondition.ts | 50 ++ .../src/openshift/V1ReplicaSetList.ts | 47 ++ .../src/openshift/V1ReplicaSetSpec.ts | 47 ++ .../src/openshift/V1ReplicaSetStatus.ts | 58 ++ .../src/openshift/V1ReplicationController.ts | 54 ++ .../V1ReplicationControllerCondition.ts | 50 ++ .../openshift/V1ReplicationControllerList.ts | 47 ++ .../openshift/V1ReplicationControllerSpec.ts | 46 ++ .../V1ReplicationControllerStatus.ts | 58 ++ .../src/openshift/V1ResourceAttributes.ts | 62 ++ .../src/openshift/V1ResourceFieldSelector.ts | 38 + .../src/openshift/V1ResourceQuota.ts | 54 ++ .../src/openshift/V1ResourceQuotaList.ts | 47 ++ .../src/openshift/V1ResourceQuotaSpec.ts | 40 + .../src/openshift/V1ResourceQuotaStatus.ts | 32 + .../src/openshift/V1ResourceRequirements.ts | 32 + .../src/openshift/V1ResourceRule.ts | 44 ++ .../kube-types/src/openshift/V1Role.ts | 47 ++ .../kube-types/src/openshift/V1RoleBinding.ts | 54 ++ .../src/openshift/V1RoleBindingList.ts | 47 ++ .../kube-types/src/openshift/V1RoleList.ts | 47 ++ .../kube-types/src/openshift/V1RoleRef.ts | 38 + .../src/openshift/V1RollingUpdateDaemonSet.ts | 26 + .../openshift/V1RollingUpdateDeployment.ts | 32 + .../V1RollingUpdateStatefulSetStrategy.ts | 26 + .../kube-types/src/openshift/V1Route.ts | 54 ++ .../src/openshift/V1RouteIngress.ts | 52 ++ .../src/openshift/V1RouteIngressCondition.ts | 50 ++ .../kube-types/src/openshift/V1RouteList.ts | 47 ++ .../kube-types/src/openshift/V1RoutePort.ts | 26 + .../kube-types/src/openshift/V1RouteSpec.ts | 66 ++ .../kube-types/src/openshift/V1RouteStatus.ts | 28 + .../src/openshift/V1RouteTargetReference.ts | 38 + .../src/openshift/V1SELinuxOptions.ts | 44 ++ .../kube-types/src/openshift/V1Scale.ts | 54 ++ .../V1ScaleIOPersistentVolumeSource.ts | 82 +++ .../src/openshift/V1ScaleIOVolumeSource.ts | 82 +++ .../kube-types/src/openshift/V1ScaleSpec.ts | 26 + .../kube-types/src/openshift/V1ScaleStatus.ts | 32 + .../src/openshift/V1ScopeSelector.ts | 28 + .../V1ScopedResourceSelectorRequirement.ts | 38 + .../kube-types/src/openshift/V1Secret.ts | 58 ++ .../src/openshift/V1SecretEnvSource.ts | 32 + .../src/openshift/V1SecretKeySelector.ts | 38 + .../kube-types/src/openshift/V1SecretList.ts | 47 ++ .../src/openshift/V1SecretProjection.ts | 40 + .../src/openshift/V1SecretReference.ts | 32 + .../src/openshift/V1SecretVolumeSource.ts | 46 ++ .../src/openshift/V1SecurityContext.ts | 71 ++ .../openshift/V1SelfSubjectAccessReview.ts | 54 ++ .../V1SelfSubjectAccessReviewSpec.ts | 35 + .../src/openshift/V1SelfSubjectRulesReview.ts | 54 ++ .../openshift/V1SelfSubjectRulesReviewSpec.ts | 26 + .../openshift/V1ServerAddressByClientCIDR.ts | 32 + .../kube-types/src/openshift/V1Service.ts | 54 ++ .../src/openshift/V1ServiceAccount.ts | 60 ++ .../src/openshift/V1ServiceAccountList.ts | 47 ++ .../V1ServiceAccountTokenProjection.ts | 38 + .../kube-types/src/openshift/V1ServiceList.ts | 47 ++ .../kube-types/src/openshift/V1ServicePort.ts | 50 ++ .../kube-types/src/openshift/V1ServiceSpec.ts | 101 +++ .../src/openshift/V1ServiceStatus.ts | 28 + .../src/openshift/V1SessionAffinityConfig.ts | 28 + .../kube-types/src/openshift/V1StatefulSet.ts | 54 ++ .../src/openshift/V1StatefulSetCondition.ts | 50 ++ .../src/openshift/V1StatefulSetList.ts | 47 ++ .../src/openshift/V1StatefulSetSpec.ts | 73 ++ .../src/openshift/V1StatefulSetStatus.ts | 76 ++ .../openshift/V1StatefulSetUpdateStrategy.ts | 34 + .../kube-types/src/openshift/V1Status.ts | 71 ++ .../kube-types/src/openshift/V1StatusCause.ts | 38 + .../src/openshift/V1StatusDetails.ts | 58 ++ .../src/openshift/V1StorageClass.ts | 83 +++ .../src/openshift/V1StorageClassList.ts | 47 ++ .../V1StorageOSPersistentVolumeSource.ts | 52 ++ .../src/openshift/V1StorageOSVolumeSource.ts | 52 ++ .../kube-types/src/openshift/V1Subject.ts | 44 ++ .../src/openshift/V1SubjectAccessReview.ts | 54 ++ .../openshift/V1SubjectAccessReviewSpec.ts | 59 ++ .../openshift/V1SubjectAccessReviewStatus.ts | 44 ++ .../openshift/V1SubjectRulesReviewStatus.ts | 47 ++ .../kube-types/src/openshift/V1Sysctl.ts | 32 + .../src/openshift/V1TCPSocketAction.ts | 32 + .../kube-types/src/openshift/V1TLSConfig.ts | 56 ++ .../kube-types/src/openshift/V1Taint.ts | 44 ++ .../kube-types/src/openshift/V1Template.ts | 66 ++ .../src/openshift/V1TemplateInstance.ts | 54 ++ .../openshift/V1TemplateInstanceCondition.ts | 50 ++ .../src/openshift/V1TemplateInstanceList.ts | 47 ++ .../src/openshift/V1TemplateInstanceObject.ts | 28 + .../openshift/V1TemplateInstanceRequester.ts | 44 ++ .../src/openshift/V1TemplateInstanceSpec.ts | 42 ++ .../src/openshift/V1TemplateInstanceStatus.ts | 35 + .../src/openshift/V1TemplateList.ts | 47 ++ .../kube-types/src/openshift/V1TokenReview.ts | 54 ++ .../src/openshift/V1TokenReviewSpec.ts | 26 + .../src/openshift/V1TokenReviewStatus.ts | 40 + .../kube-types/src/openshift/V1Toleration.ts | 50 ++ .../V1TopologySelectorLabelRequirement.ts | 32 + .../src/openshift/V1TopologySelectorTerm.ts | 28 + .../kube-types/src/openshift/V1UserInfo.ts | 44 ++ .../kube-types/src/openshift/V1Volume.ts | 216 ++++++ .../src/openshift/V1VolumeDevice.ts | 32 + .../kube-types/src/openshift/V1VolumeMount.ts | 50 ++ .../src/openshift/V1VolumeNodeAffinity.ts | 28 + .../src/openshift/V1VolumeProjection.ts | 49 ++ .../V1VsphereVirtualDiskVolumeSource.ts | 44 ++ .../kube-types/src/openshift/V1WatchEvent.ts | 34 + .../openshift/V1WeightedPodAffinityTerm.ts | 34 + .../src/openshift/V1beta1AggregationRule.ts | 28 + .../src/openshift/V1beta1AllowedFlexVolume.ts | 26 + .../src/openshift/V1beta1AllowedHostPath.ts | 32 + .../V1beta1CertificateSigningRequest.ts | 54 ++ ...beta1CertificateSigningRequestCondition.ts | 44 ++ .../V1beta1CertificateSigningRequestList.ts | 47 ++ .../V1beta1CertificateSigningRequestSpec.ts | 56 ++ .../V1beta1CertificateSigningRequestStatus.ts | 34 + .../src/openshift/V1beta1ClusterRole.ts | 54 ++ .../openshift/V1beta1ClusterRoleBinding.ts | 54 ++ .../V1beta1ClusterRoleBindingList.ts | 47 ++ .../src/openshift/V1beta1ClusterRoleList.ts | 47 ++ .../openshift/V1beta1ControllerRevision.ts | 53 ++ .../V1beta1ControllerRevisionList.ts | 47 ++ .../src/openshift/V1beta1CronJob.ts | 54 ++ .../src/openshift/V1beta1CronJobList.ts | 47 ++ .../src/openshift/V1beta1CronJobSpec.ts | 64 ++ .../src/openshift/V1beta1CronJobStatus.ts | 34 + .../src/openshift/V1beta1Deployment.ts | 54 ++ .../openshift/V1beta1DeploymentCondition.ts | 56 ++ .../src/openshift/V1beta1DeploymentList.ts | 47 ++ .../openshift/V1beta1DeploymentRollback.ts | 52 ++ .../src/openshift/V1beta1DeploymentSpec.ts | 79 ++ .../src/openshift/V1beta1DeploymentStatus.ts | 70 ++ .../openshift/V1beta1DeploymentStrategy.ts | 34 + .../kube-types/src/openshift/V1beta1Event.ts | 127 ++++ .../src/openshift/V1beta1EventList.ts | 47 ++ .../src/openshift/V1beta1EventSeries.ts | 38 + .../src/openshift/V1beta1Eviction.ts | 47 ++ .../V1beta1FSGroupStrategyOptions.ts | 34 + .../src/openshift/V1beta1HostPortRange.ts | 32 + .../src/openshift/V1beta1IDRange.ts | 32 + .../src/openshift/V1beta1JobTemplateSpec.ts | 35 + .../V1beta1LocalSubjectAccessReview.ts | 54 ++ .../V1beta1MutatingWebhookConfiguration.ts | 47 ++ ...V1beta1MutatingWebhookConfigurationList.ts | 47 ++ .../openshift/V1beta1NonResourceAttributes.ts | 32 + .../src/openshift/V1beta1NonResourceRule.ts | 32 + .../openshift/V1beta1PodDisruptionBudget.ts | 54 ++ .../V1beta1PodDisruptionBudgetList.ts | 47 ++ .../V1beta1PodDisruptionBudgetSpec.ts | 40 + .../V1beta1PodDisruptionBudgetStatus.ts | 56 ++ .../src/openshift/V1beta1PodSecurityPolicy.ts | 47 ++ .../openshift/V1beta1PodSecurityPolicyList.ts | 47 ++ .../openshift/V1beta1PodSecurityPolicySpec.ts | 148 ++++ .../src/openshift/V1beta1PolicyRule.ts | 50 ++ .../src/openshift/V1beta1PriorityClass.ts | 58 ++ .../src/openshift/V1beta1PriorityClassList.ts | 47 ++ .../openshift/V1beta1ResourceAttributes.ts | 62 ++ .../src/openshift/V1beta1ResourceRule.ts | 44 ++ .../kube-types/src/openshift/V1beta1Role.ts | 47 ++ .../src/openshift/V1beta1RoleBinding.ts | 54 ++ .../src/openshift/V1beta1RoleBindingList.ts | 47 ++ .../src/openshift/V1beta1RoleList.ts | 47 ++ .../src/openshift/V1beta1RoleRef.ts | 38 + .../src/openshift/V1beta1RollbackConfig.ts | 26 + .../V1beta1RollingUpdateDeployment.ts | 32 + ...V1beta1RollingUpdateStatefulSetStrategy.ts | 26 + .../openshift/V1beta1RuleWithOperations.ts | 44 ++ .../V1beta1RunAsUserStrategyOptions.ts | 34 + .../V1beta1SELinuxStrategyOptions.ts | 34 + .../kube-types/src/openshift/V1beta1Scale.ts | 54 ++ .../src/openshift/V1beta1ScaleSpec.ts | 26 + .../src/openshift/V1beta1ScaleStatus.ts | 38 + .../V1beta1SelfSubjectAccessReview.ts | 54 ++ .../V1beta1SelfSubjectAccessReviewSpec.ts | 35 + .../V1beta1SelfSubjectRulesReview.ts | 54 ++ .../V1beta1SelfSubjectRulesReviewSpec.ts | 26 + .../src/openshift/V1beta1ServiceReference.ts | 38 + .../src/openshift/V1beta1StatefulSet.ts | 54 ++ .../openshift/V1beta1StatefulSetCondition.ts | 50 ++ .../src/openshift/V1beta1StatefulSetList.ts | 47 ++ .../src/openshift/V1beta1StatefulSetSpec.ts | 73 ++ .../src/openshift/V1beta1StatefulSetStatus.ts | 76 ++ .../V1beta1StatefulSetUpdateStrategy.ts | 34 + .../src/openshift/V1beta1StorageClass.ts | 83 +++ .../src/openshift/V1beta1StorageClassList.ts | 47 ++ .../src/openshift/V1beta1Subject.ts | 44 ++ .../openshift/V1beta1SubjectAccessReview.ts | 54 ++ .../V1beta1SubjectAccessReviewSpec.ts | 59 ++ .../V1beta1SubjectAccessReviewStatus.ts | 44 ++ .../V1beta1SubjectRulesReviewStatus.ts | 47 ++ ...1beta1SupplementalGroupsStrategyOptions.ts | 34 + .../src/openshift/V1beta1TokenReview.ts | 54 ++ .../src/openshift/V1beta1TokenReviewSpec.ts | 26 + .../src/openshift/V1beta1TokenReviewStatus.ts | 40 + .../src/openshift/V1beta1UserInfo.ts | 44 ++ .../V1beta1ValidatingWebhookConfiguration.ts | 47 ++ ...beta1ValidatingWebhookConfigurationList.ts | 47 ++ .../src/openshift/V1beta1VolumeAttachment.ts | 54 ++ .../openshift/V1beta1VolumeAttachmentList.ts | 47 ++ .../V1beta1VolumeAttachmentSource.ts | 26 + .../openshift/V1beta1VolumeAttachmentSpec.ts | 40 + .../V1beta1VolumeAttachmentStatus.ts | 46 ++ .../src/openshift/V1beta1VolumeError.ts | 32 + .../src/openshift/V1beta1Webhook.ts | 54 ++ .../openshift/V1beta1WebhookClientConfig.ts | 40 + .../openshift/V1beta2ControllerRevision.ts | 53 ++ .../V1beta2ControllerRevisionList.ts | 47 ++ .../src/openshift/V1beta2DaemonSet.ts | 54 ++ .../openshift/V1beta2DaemonSetCondition.ts | 50 ++ .../src/openshift/V1beta2DaemonSetList.ts | 47 ++ .../src/openshift/V1beta2DaemonSetSpec.ts | 54 ++ .../src/openshift/V1beta2DaemonSetStatus.ts | 82 +++ .../V1beta2DaemonSetUpdateStrategy.ts | 34 + .../src/openshift/V1beta2Deployment.ts | 54 ++ .../openshift/V1beta2DeploymentCondition.ts | 56 ++ .../src/openshift/V1beta2DeploymentList.ts | 47 ++ .../src/openshift/V1beta2DeploymentSpec.ts | 72 ++ .../src/openshift/V1beta2DeploymentStatus.ts | 70 ++ .../openshift/V1beta2DeploymentStrategy.ts | 34 + .../src/openshift/V1beta2ReplicaSet.ts | 54 ++ .../openshift/V1beta2ReplicaSetCondition.ts | 50 ++ .../src/openshift/V1beta2ReplicaSetList.ts | 47 ++ .../src/openshift/V1beta2ReplicaSetSpec.ts | 47 ++ .../src/openshift/V1beta2ReplicaSetStatus.ts | 58 ++ .../V1beta2RollingUpdateDaemonSet.ts | 26 + .../V1beta2RollingUpdateDeployment.ts | 32 + ...V1beta2RollingUpdateStatefulSetStrategy.ts | 26 + .../kube-types/src/openshift/V1beta2Scale.ts | 54 ++ .../src/openshift/V1beta2ScaleSpec.ts | 26 + .../src/openshift/V1beta2ScaleStatus.ts | 38 + .../src/openshift/V1beta2StatefulSet.ts | 54 ++ .../openshift/V1beta2StatefulSetCondition.ts | 50 ++ .../src/openshift/V1beta2StatefulSetList.ts | 47 ++ .../src/openshift/V1beta2StatefulSetSpec.ts | 73 ++ .../src/openshift/V1beta2StatefulSetStatus.ts | 76 ++ .../V1beta2StatefulSetUpdateStrategy.ts | 34 + .../V2beta1CrossVersionObjectReference.ts | 38 + .../openshift/V2beta1ExternalMetricSource.ts | 46 ++ .../openshift/V2beta1ExternalMetricStatus.ts | 46 ++ .../V2beta1HorizontalPodAutoscaler.ts | 54 ++ ...V2beta1HorizontalPodAutoscalerCondition.ts | 50 ++ .../V2beta1HorizontalPodAutoscalerList.ts | 47 ++ .../V2beta1HorizontalPodAutoscalerSpec.ts | 47 ++ .../V2beta1HorizontalPodAutoscalerStatus.ts | 59 ++ .../src/openshift/V2beta1MetricSpec.ts | 55 ++ .../src/openshift/V2beta1MetricStatus.ts | 55 ++ .../openshift/V2beta1ObjectMetricSource.ts | 40 + .../openshift/V2beta1ObjectMetricStatus.ts | 40 + .../src/openshift/V2beta1PodsMetricSource.ts | 32 + .../src/openshift/V2beta1PodsMetricStatus.ts | 32 + .../openshift/V2beta1ResourceMetricSource.ts | 38 + .../openshift/V2beta1ResourceMetricStatus.ts | 38 + .../kube-types/src/openshift/index.ts | 691 ++++++++++++++++++ 692 files changed, 33838 insertions(+) create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1APIService.ts create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceList.ts create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1ServiceReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIService.ts create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceList.ts create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1ServiceReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1AllowedFlexVolume.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1AllowedHostPath.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetList.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetUpdateStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Deployment.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentList.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentRollback.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1FSGroupStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HTTPIngressPath.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HTTPIngressRuleValue.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HostPortRange.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IDRange.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IPBlock.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Ingress.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressBackend.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressList.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressTLS.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicy.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyEgressRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyIngressRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyList.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyPeer.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyPort.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicySpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicy.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicyList.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicySpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetList.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollbackConfig.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollingUpdateDaemonSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollingUpdateDeployment.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RunAsUserStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1SELinuxStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Scale.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ScaleSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ScaleStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/ExtensionsV1beta1SupplementalGroupsStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/IoK8sApimachineryPkgRuntimeRawExtension.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1AllowedFlexVolume.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1AppliedClusterResourceQuota.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1AppliedClusterResourceQuotaList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BinaryBuildSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BitbucketWebHookCause.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1Build.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildConfig.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildConfigList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildConfigSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildConfigStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildLog.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildOutput.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildPostCommitSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildRequest.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildStatusOutput.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildStatusOutputTo.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildTriggerCause.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1BuildTriggerPolicy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterNetwork.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterNetworkEntry.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterNetworkList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuota.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaSelector.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterRole.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterRoleBinding.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterRoleBindingList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterRoleList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ClusterRoleScopeRestriction.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ConfigMapBuildSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1CustomBuildStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1CustomDeploymentStrategyParams.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentCause.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentCauseImageTrigger.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentConfig.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigRollback.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigRollbackSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentDetails.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentLog.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentRequest.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentTriggerImageChangeParams.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DeploymentTriggerPolicy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DockerBuildStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1DockerStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyPeer.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicySpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ExecNewPodHook.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1FSGroupStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1GenericWebHookCause.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1GitBuildSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1GitHubWebHookCause.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1GitLabWebHookCause.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1GitSourceRevision.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1Group.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1GroupList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1GroupRestriction.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1HostSubnet.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1HostSubnetList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1IDRange.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1Identity.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1IdentityList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1Image.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageBlobReferences.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageChangeCause.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageChangeTrigger.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageImportSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageImportStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageLabel.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageLayer.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageLayerData.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageLookupPolicy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageSignature.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageSourcePath.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStream.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStreamImage.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStreamImport.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStreamImportSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStreamImportStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStreamLayers.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStreamList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStreamMapping.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStreamSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStreamStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStreamTag.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ImageStreamTagList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1JenkinsPipelineBuildStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1LifecycleHook.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1LocalResourceAccessReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1LocalSubjectAccessReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1NamedTagEventList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1NetNamespace.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1NetNamespaceList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1OAuthAccessToken.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1OAuthAccessTokenList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1OAuthAuthorizeToken.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1OAuthAuthorizeTokenList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1OAuthClient.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1OAuthClientAuthorization.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1OAuthClientAuthorizationList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1OAuthClientList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReviewStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySelfSubjectReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySelfSubjectReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReviewStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1PolicyRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RangeAllocation.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RangeAllocationList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RecreateDeploymentStrategyParams.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RepositoryImportSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RepositoryImportStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ResourceAccessReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ResourceQuotaStatusByNamespace.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1Role.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RoleBinding.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RoleBindingList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestriction.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestrictionList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestrictionSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RoleList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RollingDeploymentStrategyParams.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1RunAsUserStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SELinuxContextStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ScopeRestriction.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SecretBuildSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SecretLocalReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SecretSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SecurityContextConstraints.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SecurityContextConstraintsList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SelfSubjectRulesReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SelfSubjectRulesReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ServiceAccountPodSecurityPolicyReviewStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ServiceAccountReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1ServiceAccountRestriction.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SignatureCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SignatureIssuer.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SignatureSubject.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SourceBuildStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SourceControlUser.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SourceRevision.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SourceStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1StageInfo.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1StepInfo.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SubjectAccessReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReviewStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1SupplementalGroupsStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1TagEvent.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1TagEventCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1TagImageHook.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1TagImportPolicy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1TagReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1TagReferencePolicy.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1User.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1UserIdentityMapping.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1UserList.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1UserRestriction.ts create mode 100644 frontend/packages/kube-types/src/openshift/OSV1WebHookTrigger.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1APIGroup.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1APIGroupList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1APIResource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1APIResourceList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1APIVersions.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1AWSElasticBlockStoreVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Affinity.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1AggregationRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1AttachedVolume.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1AzureDiskVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1AzureFilePersistentVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1AzureFileVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Binding.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstance.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstanceList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstanceSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1CSIPersistentVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Capabilities.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1CephFSPersistentVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1CephFSVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1CinderPersistentVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1CinderVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ClientIPConfig.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ClusterRole.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ClusterRoleBinding.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ClusterRoleBindingList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ClusterRoleList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ComponentCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ComponentStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ComponentStatusList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ConfigMap.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ConfigMapEnvSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ConfigMapKeySelector.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ConfigMapList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ConfigMapNodeConfigSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ConfigMapProjection.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ConfigMapVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Container.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ContainerImage.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ContainerPort.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ContainerState.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ContainerStateRunning.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ContainerStateTerminated.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ContainerStateWaiting.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ContainerStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ControllerRevision.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ControllerRevisionList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1CrossVersionObjectReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DaemonEndpoint.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DaemonSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DaemonSetCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DaemonSetList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DaemonSetSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DaemonSetStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DaemonSetUpdateStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DeleteOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Deployment.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DeploymentCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DeploymentList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DeploymentSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DeploymentStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DeploymentStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DownwardAPIProjection.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DownwardAPIVolumeFile.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1DownwardAPIVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1EmptyDirVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1EndpointAddress.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1EndpointPort.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1EndpointSubset.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Endpoints.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1EndpointsList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1EnvFromSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1EnvVar.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1EnvVarSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Event.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1EventList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1EventSeries.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1EventSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ExecAction.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1FCVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1FlexPersistentVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1FlexVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1FlockerVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1GCEPersistentDiskVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1GitRepoVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1GlusterfsVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1GroupVersionForDiscovery.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1HTTPGetAction.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1HTTPHeader.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Handler.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscaler.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1HostAlias.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1HostPathVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1IPBlock.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ISCSIPersistentVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ISCSIVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Initializer.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Initializers.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Job.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1JobCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1JobList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1JobSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1JobStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1KeyToPath.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1LabelSelector.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1LabelSelectorRequirement.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Lifecycle.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1LimitRange.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1LimitRangeItem.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1LimitRangeList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1LimitRangeSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ListMeta.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1LoadBalancerIngress.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1LoadBalancerStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1LocalObjectReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1LocalSubjectAccessReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1LocalVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NFSVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Namespace.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NamespaceList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NamespaceSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NamespaceStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NetworkPolicy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NetworkPolicyEgressRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NetworkPolicyIngressRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NetworkPolicyList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NetworkPolicyPeer.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NetworkPolicyPort.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NetworkPolicySpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Node.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeAddress.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeAffinity.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeConfigSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeConfigStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeDaemonEndpoints.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeSelector.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeSelectorRequirement.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeSelectorTerm.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NodeSystemInfo.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NonResourceAttributes.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1NonResourceRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ObjectFieldSelector.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ObjectMeta.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ObjectReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1OwnerReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Parameter.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PersistentVolume.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaim.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PersistentVolumeList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PersistentVolumeSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PersistentVolumeStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PhotonPersistentDiskVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Pod.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodAffinity.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodAffinityTerm.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodAntiAffinity.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodDNSConfig.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodDNSConfigOption.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodReadinessGate.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodSecurityContext.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodTemplate.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodTemplateList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PodTemplateSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PolicyRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PortworxVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Preconditions.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1PreferredSchedulingTerm.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Probe.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Project.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ProjectList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ProjectRequest.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ProjectSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ProjectStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ProjectedVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1QuobyteVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RBDPersistentVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RBDVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ReplicaSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ReplicaSetCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ReplicaSetList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ReplicaSetSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ReplicaSetStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ReplicationController.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ReplicationControllerCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ReplicationControllerList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ReplicationControllerSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ReplicationControllerStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ResourceAttributes.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ResourceFieldSelector.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ResourceQuota.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ResourceQuotaList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ResourceQuotaSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ResourceQuotaStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ResourceRequirements.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ResourceRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Role.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RoleBinding.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RoleBindingList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RoleList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RoleRef.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RollingUpdateDaemonSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RollingUpdateDeployment.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RollingUpdateStatefulSetStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Route.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RouteIngress.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RouteIngressCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RouteList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RoutePort.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RouteSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RouteStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1RouteTargetReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SELinuxOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Scale.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ScaleIOPersistentVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ScaleIOVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ScaleSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ScaleStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ScopeSelector.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ScopedResourceSelectorRequirement.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Secret.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SecretEnvSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SecretKeySelector.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SecretList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SecretProjection.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SecretReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SecretVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SecurityContext.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SelfSubjectAccessReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SelfSubjectAccessReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SelfSubjectRulesReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SelfSubjectRulesReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ServerAddressByClientCIDR.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Service.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ServiceAccount.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ServiceAccountList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ServiceAccountTokenProjection.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ServiceList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ServicePort.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ServiceSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1ServiceStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SessionAffinityConfig.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StatefulSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StatefulSetCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StatefulSetList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StatefulSetSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StatefulSetStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StatefulSetUpdateStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Status.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StatusCause.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StatusDetails.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StorageClass.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StorageClassList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StorageOSPersistentVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1StorageOSVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Subject.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SubjectAccessReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SubjectAccessReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SubjectAccessReviewStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1SubjectRulesReviewStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Sysctl.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TCPSocketAction.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TLSConfig.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Taint.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Template.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TemplateInstance.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TemplateInstanceCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TemplateInstanceList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TemplateInstanceObject.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TemplateInstanceRequester.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TemplateInstanceSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TemplateInstanceStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TemplateList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TokenReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TokenReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TokenReviewStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Toleration.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TopologySelectorLabelRequirement.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1TopologySelectorTerm.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1UserInfo.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1Volume.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1VolumeDevice.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1VolumeMount.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1VolumeNodeAffinity.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1VolumeProjection.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1VsphereVirtualDiskVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1WatchEvent.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1WeightedPodAffinityTerm.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1AggregationRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1AllowedFlexVolume.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1AllowedHostPath.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequest.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ClusterRole.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleBinding.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleBindingList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ControllerRevision.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ControllerRevisionList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1CronJob.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1CronJobList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1CronJobSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1CronJobStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1Deployment.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1DeploymentCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1DeploymentList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1DeploymentRollback.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1DeploymentSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1DeploymentStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1DeploymentStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1Event.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1EventList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1EventSeries.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1Eviction.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1FSGroupStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1HostPortRange.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1IDRange.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1JobTemplateSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1LocalSubjectAccessReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1MutatingWebhookConfiguration.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1MutatingWebhookConfigurationList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1NonResourceAttributes.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1NonResourceRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudget.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicyList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicySpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1PolicyRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1PriorityClass.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1PriorityClassList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ResourceAttributes.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ResourceRule.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1Role.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1RoleBinding.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1RoleBindingList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1RoleList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1RoleRef.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1RollbackConfig.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1RollingUpdateDeployment.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1RollingUpdateStatefulSetStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1RuleWithOperations.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1RunAsUserStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1SELinuxStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1Scale.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ScaleSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ScaleStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectAccessReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectAccessReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectRulesReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectRulesReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ServiceReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1StatefulSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1StatefulSetCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1StatefulSetList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1StatefulSetSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1StatefulSetStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1StatefulSetUpdateStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1StorageClass.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1StorageClassList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1Subject.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReviewStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1SubjectRulesReviewStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1SupplementalGroupsStrategyOptions.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1TokenReview.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1TokenReviewSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1TokenReviewStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1UserInfo.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ValidatingWebhookConfiguration.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1ValidatingWebhookConfigurationList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachment.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1VolumeError.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1Webhook.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta1WebhookClientConfig.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2ControllerRevision.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2ControllerRevisionList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2DaemonSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2DaemonSetCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2DaemonSetList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2DaemonSetSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2DaemonSetStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2DaemonSetUpdateStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2Deployment.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2DeploymentCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2DeploymentList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2DeploymentSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2DeploymentStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2DeploymentStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2ReplicaSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateDaemonSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateDeployment.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateStatefulSetStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2Scale.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2ScaleSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2ScaleStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2StatefulSet.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2StatefulSetCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2StatefulSetList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2StatefulSetSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2StatefulSetStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V1beta2StatefulSetUpdateStrategy.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1CrossVersionObjectReference.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1ExternalMetricSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1ExternalMetricStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscaler.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerCondition.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerList.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1MetricSpec.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1MetricStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1ObjectMetricSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1ObjectMetricStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1PodsMetricSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1PodsMetricStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1ResourceMetricSource.ts create mode 100644 frontend/packages/kube-types/src/openshift/V2beta1ResourceMetricStatus.ts create mode 100644 frontend/packages/kube-types/src/openshift/index.ts diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIService.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIService.ts new file mode 100644 index 00000000000..c42fcdd9173 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIService.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { APIRegistrationV1APIServiceSpec } from './APIRegistrationV1APIServiceSpec'; +import { APIRegistrationV1APIServiceStatus } from './APIRegistrationV1APIServiceStatus'; + +/** + * APIService represents a server for a particular GroupVersion. Name must be \"version.group\". + * @export + * @interface APIRegistrationV1APIService + */ +export interface APIRegistrationV1APIService { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof APIRegistrationV1APIService + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof APIRegistrationV1APIService + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof APIRegistrationV1APIService + */ + metadata?: V1ObjectMeta; + /** + * + * @type {APIRegistrationV1APIServiceSpec} + * @memberof APIRegistrationV1APIService + */ + spec?: APIRegistrationV1APIServiceSpec; + /** + * + * @type {APIRegistrationV1APIServiceStatus} + * @memberof APIRegistrationV1APIService + */ + status?: APIRegistrationV1APIServiceStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceCondition.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceCondition.ts new file mode 100644 index 00000000000..37b12673e51 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface APIRegistrationV1APIServiceCondition + */ +export interface APIRegistrationV1APIServiceCondition { + /** + * + * @type {string} + * @memberof APIRegistrationV1APIServiceCondition + */ + lastTransitionTime?: string; + /** + * Human-readable message indicating details about last transition. + * @type {string} + * @memberof APIRegistrationV1APIServiceCondition + */ + message?: string; + /** + * Unique, one-word, CamelCase reason for the condition\'s last transition. + * @type {string} + * @memberof APIRegistrationV1APIServiceCondition + */ + reason?: string; + /** + * Status is the status of the condition. Can be True, False, Unknown. + * @type {string} + * @memberof APIRegistrationV1APIServiceCondition + */ + status: string; + /** + * Type is the type of the condition. + * @type {string} + * @memberof APIRegistrationV1APIServiceCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceList.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceList.ts new file mode 100644 index 00000000000..b0daf68cf58 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ListMeta } from './V1ListMeta'; +import { APIRegistrationV1APIService } from './APIRegistrationV1APIService'; + +/** + * APIServiceList is a list of APIService objects. + * @export + * @interface APIRegistrationV1APIServiceList + */ +export interface APIRegistrationV1APIServiceList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof APIRegistrationV1APIServiceList + */ + apiVersion?: string; + /** + * + * @type {Array} + * @memberof APIRegistrationV1APIServiceList + */ + items: APIRegistrationV1APIService[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof APIRegistrationV1APIServiceList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof APIRegistrationV1APIServiceList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceSpec.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceSpec.ts new file mode 100644 index 00000000000..1ffc3f321d9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceSpec.ts @@ -0,0 +1,64 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { APIRegistrationV1ServiceReference } from './APIRegistrationV1ServiceReference'; + +/** + * APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification. + * @export + * @interface APIRegistrationV1APIServiceSpec + */ +export interface APIRegistrationV1APIServiceSpec { + /** + * CABundle is a PEM encoded CA bundle which will be used to validate an API server\'s serving certificate. + * @type {string} + * @memberof APIRegistrationV1APIServiceSpec + */ + caBundle?: string; + /** + * Group is the API group name this server hosts + * @type {string} + * @memberof APIRegistrationV1APIServiceSpec + */ + group?: string; + /** + * GroupPriorityMininum is the priority this group should have at least. Higher priority means that the group is preferred by clients over lower priority ones. Note that other versions of this group might specify even higher GroupPriorityMininum values such that the whole group gets a higher priority. The primary sort is based on GroupPriorityMinimum, ordered highest number to lowest (20 before 10). The secondary sort is based on the alphabetical comparison of the name of the object. (v1.bar before v1.foo) We\'d recommend something like: *.k8s.io (except extensions) at 18000 and PaaSes (OpenShift, Deis) are recommended to be in the 2000s + * @type {number} + * @memberof APIRegistrationV1APIServiceSpec + */ + groupPriorityMinimum: number; + /** + * InsecureSkipTLSVerify disables TLS certificate verification when communicating with this server. This is strongly discouraged. You should use the CABundle instead. + * @type {boolean} + * @memberof APIRegistrationV1APIServiceSpec + */ + insecureSkipTLSVerify?: boolean; + /** + * + * @type {APIRegistrationV1ServiceReference} + * @memberof APIRegistrationV1APIServiceSpec + */ + service: APIRegistrationV1ServiceReference; + /** + * Version is the API version this server hosts. For example, \"v1\" + * @type {string} + * @memberof APIRegistrationV1APIServiceSpec + */ + version?: string; + /** + * VersionPriority controls the ordering of this API version inside of its group. Must be greater than zero. The primary sort is based on VersionPriority, ordered highest to lowest (20 before 10). Since it\'s inside of a group, the number can be small, probably in the 10s. In case of equal version priorities, the version string will be used to compute the order inside a group. If the version string is \"kube-like\", it will sort above non \"kube-like\" version strings, which are ordered lexicographically. \"Kube-like\" versions start with a \"v\", then are followed by a number (the major version), then optionally the string \"alpha\" or \"beta\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10. + * @type {number} + * @memberof APIRegistrationV1APIServiceSpec + */ + versionPriority: number; +} diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceStatus.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceStatus.ts new file mode 100644 index 00000000000..c765af3289c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1APIServiceStatus.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { APIRegistrationV1APIServiceCondition } from './APIRegistrationV1APIServiceCondition'; + +/** + * APIServiceStatus contains derived information about an API server + * @export + * @interface APIRegistrationV1APIServiceStatus + */ +export interface APIRegistrationV1APIServiceStatus { + /** + * Current service state of apiService. + * @type {Array} + * @memberof APIRegistrationV1APIServiceStatus + */ + conditions?: APIRegistrationV1APIServiceCondition[]; +} diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1ServiceReference.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1ServiceReference.ts new file mode 100644 index 00000000000..106256dba0f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1ServiceReference.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ServiceReference holds a reference to Service.legacy.k8s.io + * @export + * @interface APIRegistrationV1ServiceReference + */ +export interface APIRegistrationV1ServiceReference { + /** + * Name is the name of the service + * @type {string} + * @memberof APIRegistrationV1ServiceReference + */ + name?: string; + /** + * Namespace is the namespace of the service + * @type {string} + * @memberof APIRegistrationV1ServiceReference + */ + namespace?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIService.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIService.ts new file mode 100644 index 00000000000..7e5c3158697 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIService.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { APIRegistrationV1beta1APIServiceSpec } from './APIRegistrationV1beta1APIServiceSpec'; +import { APIRegistrationV1beta1APIServiceStatus } from './APIRegistrationV1beta1APIServiceStatus'; + +/** + * APIService represents a server for a particular GroupVersion. Name must be \"version.group\". + * @export + * @interface APIRegistrationV1beta1APIService + */ +export interface APIRegistrationV1beta1APIService { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof APIRegistrationV1beta1APIService + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof APIRegistrationV1beta1APIService + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof APIRegistrationV1beta1APIService + */ + metadata?: V1ObjectMeta; + /** + * + * @type {APIRegistrationV1beta1APIServiceSpec} + * @memberof APIRegistrationV1beta1APIService + */ + spec?: APIRegistrationV1beta1APIServiceSpec; + /** + * + * @type {APIRegistrationV1beta1APIServiceStatus} + * @memberof APIRegistrationV1beta1APIService + */ + status?: APIRegistrationV1beta1APIServiceStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceCondition.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceCondition.ts new file mode 100644 index 00000000000..2c563a2149f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface APIRegistrationV1beta1APIServiceCondition + */ +export interface APIRegistrationV1beta1APIServiceCondition { + /** + * + * @type {string} + * @memberof APIRegistrationV1beta1APIServiceCondition + */ + lastTransitionTime?: string; + /** + * Human-readable message indicating details about last transition. + * @type {string} + * @memberof APIRegistrationV1beta1APIServiceCondition + */ + message?: string; + /** + * Unique, one-word, CamelCase reason for the condition\'s last transition. + * @type {string} + * @memberof APIRegistrationV1beta1APIServiceCondition + */ + reason?: string; + /** + * Status is the status of the condition. Can be True, False, Unknown. + * @type {string} + * @memberof APIRegistrationV1beta1APIServiceCondition + */ + status: string; + /** + * Type is the type of the condition. + * @type {string} + * @memberof APIRegistrationV1beta1APIServiceCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceList.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceList.ts new file mode 100644 index 00000000000..6fad1fa9cf8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ListMeta } from './V1ListMeta'; +import { APIRegistrationV1beta1APIService } from './APIRegistrationV1beta1APIService'; + +/** + * APIServiceList is a list of APIService objects. + * @export + * @interface APIRegistrationV1beta1APIServiceList + */ +export interface APIRegistrationV1beta1APIServiceList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof APIRegistrationV1beta1APIServiceList + */ + apiVersion?: string; + /** + * + * @type {Array} + * @memberof APIRegistrationV1beta1APIServiceList + */ + items: APIRegistrationV1beta1APIService[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof APIRegistrationV1beta1APIServiceList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof APIRegistrationV1beta1APIServiceList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceSpec.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceSpec.ts new file mode 100644 index 00000000000..6e48981b611 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceSpec.ts @@ -0,0 +1,64 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { APIRegistrationV1beta1ServiceReference } from './APIRegistrationV1beta1ServiceReference'; + +/** + * APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification. + * @export + * @interface APIRegistrationV1beta1APIServiceSpec + */ +export interface APIRegistrationV1beta1APIServiceSpec { + /** + * CABundle is a PEM encoded CA bundle which will be used to validate an API server\'s serving certificate. + * @type {string} + * @memberof APIRegistrationV1beta1APIServiceSpec + */ + caBundle?: string; + /** + * Group is the API group name this server hosts + * @type {string} + * @memberof APIRegistrationV1beta1APIServiceSpec + */ + group?: string; + /** + * GroupPriorityMininum is the priority this group should have at least. Higher priority means that the group is preferred by clients over lower priority ones. Note that other versions of this group might specify even higher GroupPriorityMininum values such that the whole group gets a higher priority. The primary sort is based on GroupPriorityMinimum, ordered highest number to lowest (20 before 10). The secondary sort is based on the alphabetical comparison of the name of the object. (v1.bar before v1.foo) We\'d recommend something like: *.k8s.io (except extensions) at 18000 and PaaSes (OpenShift, Deis) are recommended to be in the 2000s + * @type {number} + * @memberof APIRegistrationV1beta1APIServiceSpec + */ + groupPriorityMinimum: number; + /** + * InsecureSkipTLSVerify disables TLS certificate verification when communicating with this server. This is strongly discouraged. You should use the CABundle instead. + * @type {boolean} + * @memberof APIRegistrationV1beta1APIServiceSpec + */ + insecureSkipTLSVerify?: boolean; + /** + * + * @type {APIRegistrationV1beta1ServiceReference} + * @memberof APIRegistrationV1beta1APIServiceSpec + */ + service: APIRegistrationV1beta1ServiceReference; + /** + * Version is the API version this server hosts. For example, \"v1\" + * @type {string} + * @memberof APIRegistrationV1beta1APIServiceSpec + */ + version?: string; + /** + * VersionPriority controls the ordering of this API version inside of its group. Must be greater than zero. The primary sort is based on VersionPriority, ordered highest to lowest (20 before 10). Since it\'s inside of a group, the number can be small, probably in the 10s. In case of equal version priorities, the version string will be used to compute the order inside a group. If the version string is \"kube-like\", it will sort above non \"kube-like\" version strings, which are ordered lexicographically. \"Kube-like\" versions start with a \"v\", then are followed by a number (the major version), then optionally the string \"alpha\" or \"beta\" and another number (the minor version). These are sorted first by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major version, then minor version. An example sorted list of versions: v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10. + * @type {number} + * @memberof APIRegistrationV1beta1APIServiceSpec + */ + versionPriority: number; +} diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceStatus.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceStatus.ts new file mode 100644 index 00000000000..181619821d9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1APIServiceStatus.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { APIRegistrationV1beta1APIServiceCondition } from './APIRegistrationV1beta1APIServiceCondition'; + +/** + * APIServiceStatus contains derived information about an API server + * @export + * @interface APIRegistrationV1beta1APIServiceStatus + */ +export interface APIRegistrationV1beta1APIServiceStatus { + /** + * Current service state of apiService. + * @type {Array} + * @memberof APIRegistrationV1beta1APIServiceStatus + */ + conditions?: APIRegistrationV1beta1APIServiceCondition[]; +} diff --git a/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1ServiceReference.ts b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1ServiceReference.ts new file mode 100644 index 00000000000..da43d954055 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/APIRegistrationV1beta1ServiceReference.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ServiceReference holds a reference to Service.legacy.k8s.io + * @export + * @interface APIRegistrationV1beta1ServiceReference + */ +export interface APIRegistrationV1beta1ServiceReference { + /** + * Name is the name of the service + * @type {string} + * @memberof APIRegistrationV1beta1ServiceReference + */ + name?: string; + /** + * Namespace is the namespace of the service + * @type {string} + * @memberof APIRegistrationV1beta1ServiceReference + */ + namespace?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1AllowedFlexVolume.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1AllowedFlexVolume.ts new file mode 100644 index 00000000000..cb0ff859ca1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1AllowedFlexVolume.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * AllowedFlexVolume represents a single Flexvolume that is allowed to be used. Deprecated: use AllowedFlexVolume from policy API Group instead. + * @export + * @interface ExtensionsV1beta1AllowedFlexVolume + */ +export interface ExtensionsV1beta1AllowedFlexVolume { + /** + * driver is the name of the Flexvolume driver. + * @type {string} + * @memberof ExtensionsV1beta1AllowedFlexVolume + */ + driver: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1AllowedHostPath.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1AllowedHostPath.ts new file mode 100644 index 00000000000..04e3c0cda4a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1AllowedHostPath.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * AllowedHostPath defines the host volume conditions that will be enabled by a policy for pods to use. It requires the path prefix to be defined. Deprecated: use AllowedHostPath from policy API Group instead. + * @export + * @interface ExtensionsV1beta1AllowedHostPath + */ +export interface ExtensionsV1beta1AllowedHostPath { + /** + * pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path. Examples: `/foo` would allow `/foo`, `/foo/` and `/foo/bar` `/foo` would not allow `/food` or `/etc/foo` + * @type {string} + * @memberof ExtensionsV1beta1AllowedHostPath + */ + pathPrefix?: string; + /** + * when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly. + * @type {boolean} + * @memberof ExtensionsV1beta1AllowedHostPath + */ + readOnly?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSet.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSet.ts new file mode 100644 index 00000000000..bd21036443e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSet.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1DaemonSetSpec } from './ExtensionsV1beta1DaemonSetSpec'; +import { ExtensionsV1beta1DaemonSetStatus } from './ExtensionsV1beta1DaemonSetStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * DEPRECATED - This group version of DaemonSet is deprecated by apps/v1beta2/DaemonSet. See the release notes for more information. DaemonSet represents the configuration of a daemon set. + * @export + * @interface ExtensionsV1beta1DaemonSet + */ +export interface ExtensionsV1beta1DaemonSet { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1DaemonSet + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1DaemonSet + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof ExtensionsV1beta1DaemonSet + */ + metadata?: V1ObjectMeta; + /** + * + * @type {ExtensionsV1beta1DaemonSetSpec} + * @memberof ExtensionsV1beta1DaemonSet + */ + spec?: ExtensionsV1beta1DaemonSetSpec; + /** + * + * @type {ExtensionsV1beta1DaemonSetStatus} + * @memberof ExtensionsV1beta1DaemonSet + */ + status?: ExtensionsV1beta1DaemonSetStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetCondition.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetCondition.ts new file mode 100644 index 00000000000..12d477d092c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DaemonSetCondition describes the state of a DaemonSet at a certain point. + * @export + * @interface ExtensionsV1beta1DaemonSetCondition + */ +export interface ExtensionsV1beta1DaemonSetCondition { + /** + * + * @type {string} + * @memberof ExtensionsV1beta1DaemonSetCondition + */ + lastTransitionTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof ExtensionsV1beta1DaemonSetCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof ExtensionsV1beta1DaemonSetCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof ExtensionsV1beta1DaemonSetCondition + */ + status: string; + /** + * Type of DaemonSet condition. + * @type {string} + * @memberof ExtensionsV1beta1DaemonSetCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetList.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetList.ts new file mode 100644 index 00000000000..8dc989ef5ea --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1DaemonSet } from './ExtensionsV1beta1DaemonSet'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * DaemonSetList is a collection of daemon sets. + * @export + * @interface ExtensionsV1beta1DaemonSetList + */ +export interface ExtensionsV1beta1DaemonSetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1DaemonSetList + */ + apiVersion?: string; + /** + * A list of daemon sets. + * @type {Array} + * @memberof ExtensionsV1beta1DaemonSetList + */ + items: ExtensionsV1beta1DaemonSet[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1DaemonSetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof ExtensionsV1beta1DaemonSetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetSpec.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetSpec.ts new file mode 100644 index 00000000000..516ac3c8d9d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetSpec.ts @@ -0,0 +1,60 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { ExtensionsV1beta1DaemonSetUpdateStrategy } from './ExtensionsV1beta1DaemonSetUpdateStrategy'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * DaemonSetSpec is the specification of a daemon set. + * @export + * @interface ExtensionsV1beta1DaemonSetSpec + */ +export interface ExtensionsV1beta1DaemonSetSpec { + /** + * The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetSpec + */ + minReadySeconds?: number; + /** + * The number of old history to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetSpec + */ + revisionHistoryLimit?: number; + /** + * + * @type {V1LabelSelector} + * @memberof ExtensionsV1beta1DaemonSetSpec + */ + selector?: V1LabelSelector; + /** + * + * @type {V1PodTemplateSpec} + * @memberof ExtensionsV1beta1DaemonSetSpec + */ + template: V1PodTemplateSpec; + /** + * DEPRECATED. A sequence number representing a specific generation of the template. Populated by the system. It can be set only during the creation. + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetSpec + */ + templateGeneration?: number; + /** + * + * @type {ExtensionsV1beta1DaemonSetUpdateStrategy} + * @memberof ExtensionsV1beta1DaemonSetSpec + */ + updateStrategy?: ExtensionsV1beta1DaemonSetUpdateStrategy; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetStatus.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetStatus.ts new file mode 100644 index 00000000000..8d6531bc983 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetStatus.ts @@ -0,0 +1,82 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1DaemonSetCondition } from './ExtensionsV1beta1DaemonSetCondition'; + +/** + * DaemonSetStatus represents the current status of a daemon set. + * @export + * @interface ExtensionsV1beta1DaemonSetStatus + */ +export interface ExtensionsV1beta1DaemonSetStatus { + /** + * Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetStatus + */ + collisionCount?: number; + /** + * Represents the latest available observations of a DaemonSet\'s current state. + * @type {Array} + * @memberof ExtensionsV1beta1DaemonSetStatus + */ + conditions?: ExtensionsV1beta1DaemonSetCondition[]; + /** + * The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetStatus + */ + currentNumberScheduled: number; + /** + * The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetStatus + */ + desiredNumberScheduled: number; + /** + * The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds) + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetStatus + */ + numberAvailable?: number; + /** + * The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetStatus + */ + numberMisscheduled: number; + /** + * The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and ready. + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetStatus + */ + numberReady: number; + /** + * The number of nodes that should be running the daemon pod and have none of the daemon pod running and available (ready for at least spec.minReadySeconds) + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetStatus + */ + numberUnavailable?: number; + /** + * The most recent generation observed by the daemon set controller. + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetStatus + */ + observedGeneration?: number; + /** + * The total number of nodes that are running updated daemon pod + * @type {number} + * @memberof ExtensionsV1beta1DaemonSetStatus + */ + updatedNumberScheduled?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetUpdateStrategy.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetUpdateStrategy.ts new file mode 100644 index 00000000000..c1f3f88765f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DaemonSetUpdateStrategy.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1RollingUpdateDaemonSet } from './ExtensionsV1beta1RollingUpdateDaemonSet'; + +/** + * + * @export + * @interface ExtensionsV1beta1DaemonSetUpdateStrategy + */ +export interface ExtensionsV1beta1DaemonSetUpdateStrategy { + /** + * + * @type {ExtensionsV1beta1RollingUpdateDaemonSet} + * @memberof ExtensionsV1beta1DaemonSetUpdateStrategy + */ + rollingUpdate?: ExtensionsV1beta1RollingUpdateDaemonSet; + /** + * Type of daemon set update. Can be \"RollingUpdate\" or \"OnDelete\". Default is OnDelete. + * @type {string} + * @memberof ExtensionsV1beta1DaemonSetUpdateStrategy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Deployment.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Deployment.ts new file mode 100644 index 00000000000..9cc79155f12 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Deployment.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1DeploymentSpec } from './ExtensionsV1beta1DeploymentSpec'; +import { ExtensionsV1beta1DeploymentStatus } from './ExtensionsV1beta1DeploymentStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * DEPRECATED - This group version of Deployment is deprecated by apps/v1beta2/Deployment. See the release notes for more information. Deployment enables declarative updates for Pods and ReplicaSets. + * @export + * @interface ExtensionsV1beta1Deployment + */ +export interface ExtensionsV1beta1Deployment { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1Deployment + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1Deployment + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof ExtensionsV1beta1Deployment + */ + metadata?: V1ObjectMeta; + /** + * + * @type {ExtensionsV1beta1DeploymentSpec} + * @memberof ExtensionsV1beta1Deployment + */ + spec?: ExtensionsV1beta1DeploymentSpec; + /** + * + * @type {ExtensionsV1beta1DeploymentStatus} + * @memberof ExtensionsV1beta1Deployment + */ + status?: ExtensionsV1beta1DeploymentStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentCondition.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentCondition.ts new file mode 100644 index 00000000000..3c34d760569 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentCondition.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DeploymentCondition describes the state of a deployment at a certain point. + * @export + * @interface ExtensionsV1beta1DeploymentCondition + */ +export interface ExtensionsV1beta1DeploymentCondition { + /** + * + * @type {string} + * @memberof ExtensionsV1beta1DeploymentCondition + */ + lastTransitionTime?: string; + /** + * + * @type {string} + * @memberof ExtensionsV1beta1DeploymentCondition + */ + lastUpdateTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof ExtensionsV1beta1DeploymentCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof ExtensionsV1beta1DeploymentCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof ExtensionsV1beta1DeploymentCondition + */ + status: string; + /** + * Type of deployment condition. + * @type {string} + * @memberof ExtensionsV1beta1DeploymentCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentList.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentList.ts new file mode 100644 index 00000000000..9221eee792e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1Deployment } from './ExtensionsV1beta1Deployment'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * DeploymentList is a list of Deployments. + * @export + * @interface ExtensionsV1beta1DeploymentList + */ +export interface ExtensionsV1beta1DeploymentList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1DeploymentList + */ + apiVersion?: string; + /** + * Items is the list of Deployments. + * @type {Array} + * @memberof ExtensionsV1beta1DeploymentList + */ + items: ExtensionsV1beta1Deployment[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1DeploymentList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof ExtensionsV1beta1DeploymentList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentRollback.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentRollback.ts new file mode 100644 index 00000000000..f5acadb5a8a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentRollback.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1RollbackConfig } from './ExtensionsV1beta1RollbackConfig'; + +/** + * DEPRECATED. DeploymentRollback stores the information required to rollback a deployment. + * @export + * @interface ExtensionsV1beta1DeploymentRollback + */ +export interface ExtensionsV1beta1DeploymentRollback { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1DeploymentRollback + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1DeploymentRollback + */ + kind?: string; + /** + * Required: This must match the Name of a deployment. + * @type {string} + * @memberof ExtensionsV1beta1DeploymentRollback + */ + name: string; + /** + * + * @type {ExtensionsV1beta1RollbackConfig} + * @memberof ExtensionsV1beta1DeploymentRollback + */ + rollbackTo: ExtensionsV1beta1RollbackConfig; + /** + * The annotations to be updated to a deployment + * @type {{ [key: string]: string; }} + * @memberof ExtensionsV1beta1DeploymentRollback + */ + updatedAnnotations?: { [key: string]: string }; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentSpec.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentSpec.ts new file mode 100644 index 00000000000..d7e9d15a7f1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentSpec.ts @@ -0,0 +1,79 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { ExtensionsV1beta1DeploymentStrategy } from './ExtensionsV1beta1DeploymentStrategy'; +import { ExtensionsV1beta1RollbackConfig } from './ExtensionsV1beta1RollbackConfig'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * DeploymentSpec is the specification of the desired behavior of the Deployment. + * @export + * @interface ExtensionsV1beta1DeploymentSpec + */ +export interface ExtensionsV1beta1DeploymentSpec { + /** + * Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) + * @type {number} + * @memberof ExtensionsV1beta1DeploymentSpec + */ + minReadySeconds?: number; + /** + * Indicates that the deployment is paused and will not be processed by the deployment controller. + * @type {boolean} + * @memberof ExtensionsV1beta1DeploymentSpec + */ + paused?: boolean; + /** + * The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. This is not set by default. + * @type {number} + * @memberof ExtensionsV1beta1DeploymentSpec + */ + progressDeadlineSeconds?: number; + /** + * Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. + * @type {number} + * @memberof ExtensionsV1beta1DeploymentSpec + */ + replicas?: number; + /** + * The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. + * @type {number} + * @memberof ExtensionsV1beta1DeploymentSpec + */ + revisionHistoryLimit?: number; + /** + * + * @type {ExtensionsV1beta1RollbackConfig} + * @memberof ExtensionsV1beta1DeploymentSpec + */ + rollbackTo?: ExtensionsV1beta1RollbackConfig; + /** + * + * @type {V1LabelSelector} + * @memberof ExtensionsV1beta1DeploymentSpec + */ + selector?: V1LabelSelector; + /** + * + * @type {ExtensionsV1beta1DeploymentStrategy} + * @memberof ExtensionsV1beta1DeploymentSpec + */ + strategy?: ExtensionsV1beta1DeploymentStrategy; + /** + * + * @type {V1PodTemplateSpec} + * @memberof ExtensionsV1beta1DeploymentSpec + */ + template: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentStatus.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentStatus.ts new file mode 100644 index 00000000000..06a65121608 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentStatus.ts @@ -0,0 +1,70 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1DeploymentCondition } from './ExtensionsV1beta1DeploymentCondition'; + +/** + * DeploymentStatus is the most recently observed status of the Deployment. + * @export + * @interface ExtensionsV1beta1DeploymentStatus + */ +export interface ExtensionsV1beta1DeploymentStatus { + /** + * Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. + * @type {number} + * @memberof ExtensionsV1beta1DeploymentStatus + */ + availableReplicas?: number; + /** + * Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet. + * @type {number} + * @memberof ExtensionsV1beta1DeploymentStatus + */ + collisionCount?: number; + /** + * Represents the latest available observations of a deployment\'s current state. + * @type {Array} + * @memberof ExtensionsV1beta1DeploymentStatus + */ + conditions?: ExtensionsV1beta1DeploymentCondition[]; + /** + * The generation observed by the deployment controller. + * @type {number} + * @memberof ExtensionsV1beta1DeploymentStatus + */ + observedGeneration?: number; + /** + * Total number of ready pods targeted by this deployment. + * @type {number} + * @memberof ExtensionsV1beta1DeploymentStatus + */ + readyReplicas?: number; + /** + * Total number of non-terminated pods targeted by this deployment (their labels match the selector). + * @type {number} + * @memberof ExtensionsV1beta1DeploymentStatus + */ + replicas?: number; + /** + * Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created. + * @type {number} + * @memberof ExtensionsV1beta1DeploymentStatus + */ + unavailableReplicas?: number; + /** + * Total number of non-terminated pods targeted by this deployment that have the desired template spec. + * @type {number} + * @memberof ExtensionsV1beta1DeploymentStatus + */ + updatedReplicas?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentStrategy.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentStrategy.ts new file mode 100644 index 00000000000..c01e0f5520c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1DeploymentStrategy.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1RollingUpdateDeployment } from './ExtensionsV1beta1RollingUpdateDeployment'; + +/** + * DeploymentStrategy describes how to replace existing pods with new ones. + * @export + * @interface ExtensionsV1beta1DeploymentStrategy + */ +export interface ExtensionsV1beta1DeploymentStrategy { + /** + * + * @type {ExtensionsV1beta1RollingUpdateDeployment} + * @memberof ExtensionsV1beta1DeploymentStrategy + */ + rollingUpdate?: ExtensionsV1beta1RollingUpdateDeployment; + /** + * Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate. + * @type {string} + * @memberof ExtensionsV1beta1DeploymentStrategy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1FSGroupStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1FSGroupStrategyOptions.ts new file mode 100644 index 00000000000..90845968222 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1FSGroupStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1IDRange } from './ExtensionsV1beta1IDRange'; + +/** + * FSGroupStrategyOptions defines the strategy type and options used to create the strategy. Deprecated: use FSGroupStrategyOptions from policy API Group instead. + * @export + * @interface ExtensionsV1beta1FSGroupStrategyOptions + */ +export interface ExtensionsV1beta1FSGroupStrategyOptions { + /** + * ranges are the allowed ranges of fs groups. If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs. + * @type {Array} + * @memberof ExtensionsV1beta1FSGroupStrategyOptions + */ + ranges?: ExtensionsV1beta1IDRange[]; + /** + * rule is the strategy that will dictate what FSGroup is used in the SecurityContext. + * @type {string} + * @memberof ExtensionsV1beta1FSGroupStrategyOptions + */ + rule?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HTTPIngressPath.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HTTPIngressPath.ts new file mode 100644 index 00000000000..99fbe679a63 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HTTPIngressPath.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1IngressBackend } from './ExtensionsV1beta1IngressBackend'; + +/** + * HTTPIngressPath associates a path regex with a backend. Incoming urls matching the path are forwarded to the backend. + * @export + * @interface ExtensionsV1beta1HTTPIngressPath + */ +export interface ExtensionsV1beta1HTTPIngressPath { + /** + * + * @type {ExtensionsV1beta1IngressBackend} + * @memberof ExtensionsV1beta1HTTPIngressPath + */ + backend: ExtensionsV1beta1IngressBackend; + /** + * Path is an extended POSIX regex as defined by IEEE Std 1003.1, (i.e this follows the egrep/unix syntax, not the perl syntax) matched against the path of an incoming request. Currently it can contain characters disallowed from the conventional \"path\" part of a URL as defined by RFC 3986. Paths must begin with a \'/\'. If unspecified, the path defaults to a catch all sending traffic to the backend. + * @type {string} + * @memberof ExtensionsV1beta1HTTPIngressPath + */ + path?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HTTPIngressRuleValue.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HTTPIngressRuleValue.ts new file mode 100644 index 00000000000..d23f1285449 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HTTPIngressRuleValue.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1HTTPIngressPath } from './ExtensionsV1beta1HTTPIngressPath'; + +/** + * HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http:///? -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last \'/\' and before the first \'?\' or \'#\'. + * @export + * @interface ExtensionsV1beta1HTTPIngressRuleValue + */ +export interface ExtensionsV1beta1HTTPIngressRuleValue { + /** + * A collection of paths that map requests to backends. + * @type {Array} + * @memberof ExtensionsV1beta1HTTPIngressRuleValue + */ + paths: ExtensionsV1beta1HTTPIngressPath[]; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HostPortRange.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HostPortRange.ts new file mode 100644 index 00000000000..aa1b5650a88 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1HostPortRange.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * HostPortRange defines a range of host ports that will be enabled by a policy for pods to use. It requires both the start and end to be defined. Deprecated: use HostPortRange from policy API Group instead. + * @export + * @interface ExtensionsV1beta1HostPortRange + */ +export interface ExtensionsV1beta1HostPortRange { + /** + * max is the end of the range, inclusive. + * @type {number} + * @memberof ExtensionsV1beta1HostPortRange + */ + max: number; + /** + * min is the start of the range, inclusive. + * @type {number} + * @memberof ExtensionsV1beta1HostPortRange + */ + min: number; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IDRange.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IDRange.ts new file mode 100644 index 00000000000..dacdddc5bb9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IDRange.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * IDRange provides a min/max of an allowed range of IDs. Deprecated: use IDRange from policy API Group instead. + * @export + * @interface ExtensionsV1beta1IDRange + */ +export interface ExtensionsV1beta1IDRange { + /** + * max is the end of the range, inclusive. + * @type {number} + * @memberof ExtensionsV1beta1IDRange + */ + max: number; + /** + * min is the start of the range, inclusive. + * @type {number} + * @memberof ExtensionsV1beta1IDRange + */ + min: number; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IPBlock.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IPBlock.ts new file mode 100644 index 00000000000..b8dc7b4d2a1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IPBlock.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DEPRECATED 1.9 - This group version of IPBlock is deprecated by networking/v1/IPBlock. IPBlock describes a particular CIDR (Ex. \"192.168.1.1/24\") that is allowed to the pods matched by a NetworkPolicySpec\'s podSelector. The except entry describes CIDRs that should not be included within this rule. + * @export + * @interface ExtensionsV1beta1IPBlock + */ +export interface ExtensionsV1beta1IPBlock { + /** + * CIDR is a string representing the IP Block Valid examples are \"192.168.1.1/24\" + * @type {string} + * @memberof ExtensionsV1beta1IPBlock + */ + cidr: string; + /** + * Except is a slice of CIDRs that should not be included within an IP Block Valid examples are \"192.168.1.1/24\" Except values will be rejected if they are outside the CIDR range + * @type {Array} + * @memberof ExtensionsV1beta1IPBlock + */ + except?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Ingress.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Ingress.ts new file mode 100644 index 00000000000..8bff81c8bfb --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Ingress.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1IngressSpec } from './ExtensionsV1beta1IngressSpec'; +import { ExtensionsV1beta1IngressStatus } from './ExtensionsV1beta1IngressStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc. + * @export + * @interface ExtensionsV1beta1Ingress + */ +export interface ExtensionsV1beta1Ingress { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1Ingress + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1Ingress + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof ExtensionsV1beta1Ingress + */ + metadata?: V1ObjectMeta; + /** + * + * @type {ExtensionsV1beta1IngressSpec} + * @memberof ExtensionsV1beta1Ingress + */ + spec?: ExtensionsV1beta1IngressSpec; + /** + * + * @type {ExtensionsV1beta1IngressStatus} + * @memberof ExtensionsV1beta1Ingress + */ + status?: ExtensionsV1beta1IngressStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressBackend.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressBackend.ts new file mode 100644 index 00000000000..d8dc5c42844 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressBackend.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * IngressBackend describes all endpoints for a given service and port. + * @export + * @interface ExtensionsV1beta1IngressBackend + */ +export interface ExtensionsV1beta1IngressBackend { + /** + * Specifies the name of the referenced service. + * @type {string} + * @memberof ExtensionsV1beta1IngressBackend + */ + serviceName: string; + /** + * + * @type {string} + * @memberof ExtensionsV1beta1IngressBackend + */ + servicePort: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressList.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressList.ts new file mode 100644 index 00000000000..f50a888c8fb --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1Ingress } from './ExtensionsV1beta1Ingress'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * IngressList is a collection of Ingress. + * @export + * @interface ExtensionsV1beta1IngressList + */ +export interface ExtensionsV1beta1IngressList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1IngressList + */ + apiVersion?: string; + /** + * Items is the list of Ingress. + * @type {Array} + * @memberof ExtensionsV1beta1IngressList + */ + items: ExtensionsV1beta1Ingress[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1IngressList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof ExtensionsV1beta1IngressList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressRule.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressRule.ts new file mode 100644 index 00000000000..82bdd5929dc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressRule.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1HTTPIngressRuleValue } from './ExtensionsV1beta1HTTPIngressRuleValue'; + +/** + * IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue. + * @export + * @interface ExtensionsV1beta1IngressRule + */ +export interface ExtensionsV1beta1IngressRule { + /** + * Host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the \"host\" part of the URI as defined in the RFC: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to the IP in the Spec of the parent Ingress. 2. The `:` delimiter is not respected because ports are not allowed. Currently the port of an Ingress is implicitly :80 for http and :443 for https. Both these may change in the future. Incoming requests are matched against the host before the IngressRuleValue. If the host is unspecified, the Ingress routes all traffic based on the specified IngressRuleValue. + * @type {string} + * @memberof ExtensionsV1beta1IngressRule + */ + host?: string; + /** + * + * @type {ExtensionsV1beta1HTTPIngressRuleValue} + * @memberof ExtensionsV1beta1IngressRule + */ + http?: ExtensionsV1beta1HTTPIngressRuleValue; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressSpec.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressSpec.ts new file mode 100644 index 00000000000..19b8b3c689c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressSpec.ts @@ -0,0 +1,42 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1IngressBackend } from './ExtensionsV1beta1IngressBackend'; +import { ExtensionsV1beta1IngressRule } from './ExtensionsV1beta1IngressRule'; +import { ExtensionsV1beta1IngressTLS } from './ExtensionsV1beta1IngressTLS'; + +/** + * IngressSpec describes the Ingress the user wishes to exist. + * @export + * @interface ExtensionsV1beta1IngressSpec + */ +export interface ExtensionsV1beta1IngressSpec { + /** + * + * @type {ExtensionsV1beta1IngressBackend} + * @memberof ExtensionsV1beta1IngressSpec + */ + backend?: ExtensionsV1beta1IngressBackend; + /** + * A list of host rules used to configure the Ingress. If unspecified, or no rule matches, all traffic is sent to the default backend. + * @type {Array} + * @memberof ExtensionsV1beta1IngressSpec + */ + rules?: ExtensionsV1beta1IngressRule[]; + /** + * TLS configuration. Currently the Ingress only supports a single TLS port, 443. If multiple members of this list specify different hosts, they will be multiplexed on the same port according to the hostname specified through the SNI TLS extension, if the ingress controller fulfilling the ingress supports SNI. + * @type {Array} + * @memberof ExtensionsV1beta1IngressSpec + */ + tls?: ExtensionsV1beta1IngressTLS[]; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressStatus.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressStatus.ts new file mode 100644 index 00000000000..7ae43725bec --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressStatus.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LoadBalancerStatus } from './V1LoadBalancerStatus'; + +/** + * IngressStatus describe the current state of the Ingress. + * @export + * @interface ExtensionsV1beta1IngressStatus + */ +export interface ExtensionsV1beta1IngressStatus { + /** + * + * @type {V1LoadBalancerStatus} + * @memberof ExtensionsV1beta1IngressStatus + */ + loadBalancer?: V1LoadBalancerStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressTLS.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressTLS.ts new file mode 100644 index 00000000000..850b059ee69 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1IngressTLS.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * IngressTLS describes the transport layer security associated with an Ingress. + * @export + * @interface ExtensionsV1beta1IngressTLS + */ +export interface ExtensionsV1beta1IngressTLS { + /** + * Hosts are a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified. + * @type {Array} + * @memberof ExtensionsV1beta1IngressTLS + */ + hosts?: string[]; + /** + * SecretName is the name of the secret used to terminate SSL traffic on 443. Field is left optional to allow SSL routing based on SNI hostname alone. If the SNI host in a listener conflicts with the \"Host\" header field used by an IngressRule, the SNI host is used for termination and value of the Host header is used for routing. + * @type {string} + * @memberof ExtensionsV1beta1IngressTLS + */ + secretName?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicy.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicy.ts new file mode 100644 index 00000000000..9661985b9d4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicy.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1NetworkPolicySpec } from './ExtensionsV1beta1NetworkPolicySpec'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * DEPRECATED 1.9 - This group version of NetworkPolicy is deprecated by networking/v1/NetworkPolicy. NetworkPolicy describes what network traffic is allowed for a set of Pods + * @export + * @interface ExtensionsV1beta1NetworkPolicy + */ +export interface ExtensionsV1beta1NetworkPolicy { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1NetworkPolicy + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1NetworkPolicy + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof ExtensionsV1beta1NetworkPolicy + */ + metadata?: V1ObjectMeta; + /** + * + * @type {ExtensionsV1beta1NetworkPolicySpec} + * @memberof ExtensionsV1beta1NetworkPolicy + */ + spec?: ExtensionsV1beta1NetworkPolicySpec; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyEgressRule.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyEgressRule.ts new file mode 100644 index 00000000000..3de61222c32 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyEgressRule.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1NetworkPolicyPeer } from './ExtensionsV1beta1NetworkPolicyPeer'; +import { ExtensionsV1beta1NetworkPolicyPort } from './ExtensionsV1beta1NetworkPolicyPort'; + +/** + * DEPRECATED 1.9 - This group version of NetworkPolicyEgressRule is deprecated by networking/v1/NetworkPolicyEgressRule. NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec\'s podSelector. The traffic must match both ports and to. This type is beta-level in 1.8 + * @export + * @interface ExtensionsV1beta1NetworkPolicyEgressRule + */ +export interface ExtensionsV1beta1NetworkPolicyEgressRule { + /** + * List of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. + * @type {Array} + * @memberof ExtensionsV1beta1NetworkPolicyEgressRule + */ + ports?: ExtensionsV1beta1NetworkPolicyPort[]; + /** + * List of destinations for outgoing traffic of pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all destinations (traffic not restricted by destination). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the to list. + * @type {Array} + * @memberof ExtensionsV1beta1NetworkPolicyEgressRule + */ + to?: ExtensionsV1beta1NetworkPolicyPeer[]; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyIngressRule.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyIngressRule.ts new file mode 100644 index 00000000000..6c03afc59db --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyIngressRule.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1NetworkPolicyPeer } from './ExtensionsV1beta1NetworkPolicyPeer'; +import { ExtensionsV1beta1NetworkPolicyPort } from './ExtensionsV1beta1NetworkPolicyPort'; + +/** + * DEPRECATED 1.9 - This group version of NetworkPolicyIngressRule is deprecated by networking/v1/NetworkPolicyIngressRule. This NetworkPolicyIngressRule matches traffic if and only if the traffic matches both ports AND from. + * @export + * @interface ExtensionsV1beta1NetworkPolicyIngressRule + */ +export interface ExtensionsV1beta1NetworkPolicyIngressRule { + /** + * List of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least on item, this rule allows traffic only if the traffic matches at least one item in the from list. + * @type {Array} + * @memberof ExtensionsV1beta1NetworkPolicyIngressRule + */ + from?: ExtensionsV1beta1NetworkPolicyPeer[]; + /** + * List of ports which should be made accessible on the pods selected for this rule. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. + * @type {Array} + * @memberof ExtensionsV1beta1NetworkPolicyIngressRule + */ + ports?: ExtensionsV1beta1NetworkPolicyPort[]; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyList.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyList.ts new file mode 100644 index 00000000000..bc0d19aab44 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1NetworkPolicy } from './ExtensionsV1beta1NetworkPolicy'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * DEPRECATED 1.9 - This group version of NetworkPolicyList is deprecated by networking/v1/NetworkPolicyList. Network Policy List is a list of NetworkPolicy objects. + * @export + * @interface ExtensionsV1beta1NetworkPolicyList + */ +export interface ExtensionsV1beta1NetworkPolicyList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1NetworkPolicyList + */ + apiVersion?: string; + /** + * Items is a list of schema objects. + * @type {Array} + * @memberof ExtensionsV1beta1NetworkPolicyList + */ + items: ExtensionsV1beta1NetworkPolicy[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1NetworkPolicyList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof ExtensionsV1beta1NetworkPolicyList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyPeer.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyPeer.ts new file mode 100644 index 00000000000..01f147a4721 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyPeer.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1IPBlock } from './ExtensionsV1beta1IPBlock'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * DEPRECATED 1.9 - This group version of NetworkPolicyPeer is deprecated by networking/v1/NetworkPolicyPeer. + * @export + * @interface ExtensionsV1beta1NetworkPolicyPeer + */ +export interface ExtensionsV1beta1NetworkPolicyPeer { + /** + * + * @type {ExtensionsV1beta1IPBlock} + * @memberof ExtensionsV1beta1NetworkPolicyPeer + */ + ipBlock?: ExtensionsV1beta1IPBlock; + /** + * + * @type {V1LabelSelector} + * @memberof ExtensionsV1beta1NetworkPolicyPeer + */ + namespaceSelector?: V1LabelSelector; + /** + * + * @type {V1LabelSelector} + * @memberof ExtensionsV1beta1NetworkPolicyPeer + */ + podSelector?: V1LabelSelector; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyPort.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyPort.ts new file mode 100644 index 00000000000..86c4abefb43 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicyPort.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DEPRECATED 1.9 - This group version of NetworkPolicyPort is deprecated by networking/v1/NetworkPolicyPort. + * @export + * @interface ExtensionsV1beta1NetworkPolicyPort + */ +export interface ExtensionsV1beta1NetworkPolicyPort { + /** + * + * @type {string} + * @memberof ExtensionsV1beta1NetworkPolicyPort + */ + port?: string; + /** + * Optional. The protocol (TCP or UDP) which traffic must match. If not specified, this field defaults to TCP. + * @type {string} + * @memberof ExtensionsV1beta1NetworkPolicyPort + */ + protocol?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicySpec.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicySpec.ts new file mode 100644 index 00000000000..e5bf94488b5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1NetworkPolicySpec.ts @@ -0,0 +1,48 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1NetworkPolicyEgressRule } from './ExtensionsV1beta1NetworkPolicyEgressRule'; +import { ExtensionsV1beta1NetworkPolicyIngressRule } from './ExtensionsV1beta1NetworkPolicyIngressRule'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * DEPRECATED 1.9 - This group version of NetworkPolicySpec is deprecated by networking/v1/NetworkPolicySpec. + * @export + * @interface ExtensionsV1beta1NetworkPolicySpec + */ +export interface ExtensionsV1beta1NetworkPolicySpec { + /** + * List of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8 + * @type {Array} + * @memberof ExtensionsV1beta1NetworkPolicySpec + */ + egress?: ExtensionsV1beta1NetworkPolicyEgressRule[]; + /** + * List of ingress rules to be applied to the selected pods. Traffic is allowed to a pod if there are no NetworkPolicies selecting the pod OR if the traffic source is the pod\'s local node, OR if the traffic matches at least one ingress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy does not allow any traffic (and serves solely to ensure that the pods it selects are isolated by default). + * @type {Array} + * @memberof ExtensionsV1beta1NetworkPolicySpec + */ + ingress?: ExtensionsV1beta1NetworkPolicyIngressRule[]; + /** + * + * @type {V1LabelSelector} + * @memberof ExtensionsV1beta1NetworkPolicySpec + */ + podSelector: V1LabelSelector; + /** + * List of rule types that the NetworkPolicy relates to. Valid options are Ingress, Egress, or Ingress,Egress. If this field is not specified, it will default based on the existence of Ingress or Egress rules; policies that contain an Egress section are assumed to affect Egress, and all policies (whether or not they contain an Ingress section) are assumed to affect Ingress. If you want to write an egress-only policy, you must explicitly specify policyTypes [ \"Egress\" ]. Likewise, if you want to write a policy that specifies that no egress is allowed, you must specify a policyTypes value that include \"Egress\" (since such a policy would not include an Egress section and would otherwise default to just [ \"Ingress\" ]). This field is beta-level in 1.8 + * @type {Array} + * @memberof ExtensionsV1beta1NetworkPolicySpec + */ + policyTypes?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicy.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicy.ts new file mode 100644 index 00000000000..f8b21ac2ba5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicy.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1PodSecurityPolicySpec } from './ExtensionsV1beta1PodSecurityPolicySpec'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container. Deprecated: use PodSecurityPolicy from policy API Group instead. + * @export + * @interface ExtensionsV1beta1PodSecurityPolicy + */ +export interface ExtensionsV1beta1PodSecurityPolicy { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1PodSecurityPolicy + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1PodSecurityPolicy + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof ExtensionsV1beta1PodSecurityPolicy + */ + metadata?: V1ObjectMeta; + /** + * + * @type {ExtensionsV1beta1PodSecurityPolicySpec} + * @memberof ExtensionsV1beta1PodSecurityPolicy + */ + spec?: ExtensionsV1beta1PodSecurityPolicySpec; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicyList.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicyList.ts new file mode 100644 index 00000000000..6100c90f0d0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicyList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1PodSecurityPolicy } from './ExtensionsV1beta1PodSecurityPolicy'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * PodSecurityPolicyList is a list of PodSecurityPolicy objects. Deprecated: use PodSecurityPolicyList from policy API Group instead. + * @export + * @interface ExtensionsV1beta1PodSecurityPolicyList + */ +export interface ExtensionsV1beta1PodSecurityPolicyList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1PodSecurityPolicyList + */ + apiVersion?: string; + /** + * items is a list of schema objects. + * @type {Array} + * @memberof ExtensionsV1beta1PodSecurityPolicyList + */ + items: ExtensionsV1beta1PodSecurityPolicy[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1PodSecurityPolicyList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof ExtensionsV1beta1PodSecurityPolicyList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicySpec.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicySpec.ts new file mode 100644 index 00000000000..ed380514d46 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1PodSecurityPolicySpec.ts @@ -0,0 +1,148 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1AllowedFlexVolume } from './ExtensionsV1beta1AllowedFlexVolume'; +import { ExtensionsV1beta1AllowedHostPath } from './ExtensionsV1beta1AllowedHostPath'; +import { ExtensionsV1beta1FSGroupStrategyOptions } from './ExtensionsV1beta1FSGroupStrategyOptions'; +import { ExtensionsV1beta1HostPortRange } from './ExtensionsV1beta1HostPortRange'; +import { ExtensionsV1beta1RunAsUserStrategyOptions } from './ExtensionsV1beta1RunAsUserStrategyOptions'; +import { ExtensionsV1beta1SELinuxStrategyOptions } from './ExtensionsV1beta1SELinuxStrategyOptions'; +import { ExtensionsV1beta1SupplementalGroupsStrategyOptions } from './ExtensionsV1beta1SupplementalGroupsStrategyOptions'; + +/** + * PodSecurityPolicySpec defines the policy enforced. Deprecated: use PodSecurityPolicySpec from policy API Group instead. + * @export + * @interface ExtensionsV1beta1PodSecurityPolicySpec + */ +export interface ExtensionsV1beta1PodSecurityPolicySpec { + /** + * allowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true. + * @type {boolean} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + allowPrivilegeEscalation?: boolean; + /** + * allowedCapabilities is a list of capabilities that can be requested to add to the container. Capabilities in this field may be added at the pod author\'s discretion. You must not list a capability in both allowedCapabilities and requiredDropCapabilities. + * @type {Array} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + allowedCapabilities?: string[]; + /** + * allowedFlexVolumes is a whitelist of allowed Flexvolumes. Empty or nil indicates that all Flexvolumes may be used. This parameter is effective only when the usage of the Flexvolumes is allowed in the \"volumes\" field. + * @type {Array} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + allowedFlexVolumes?: ExtensionsV1beta1AllowedFlexVolume[]; + /** + * allowedHostPaths is a white list of allowed host paths. Empty indicates that all host paths may be used. + * @type {Array} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + allowedHostPaths?: ExtensionsV1beta1AllowedHostPath[]; + /** + * allowedUnsafeSysctls is a list of explicitly allowed unsafe sysctls, defaults to none. Each entry is either a plain sysctl name or ends in \"*\" in which case it is considered as a prefix of allowed sysctls. Single * means all unsafe sysctls are allowed. Kubelet has to whitelist all allowed unsafe sysctls explicitly to avoid rejection. Examples: e.g. \"foo/_*\" allows \"foo/bar\", \"foo/baz\", etc. e.g. \"foo.*\" allows \"foo.bar\", \"foo.baz\", etc. + * @type {Array} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + allowedUnsafeSysctls?: string[]; + /** + * defaultAddCapabilities is the default set of capabilities that will be added to the container unless the pod spec specifically drops the capability. You may not list a capability in both defaultAddCapabilities and requiredDropCapabilities. Capabilities added here are implicitly allowed, and need not be included in the allowedCapabilities list. + * @type {Array} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + defaultAddCapabilities?: string[]; + /** + * defaultAllowPrivilegeEscalation controls the default setting for whether a process can gain more privileges than its parent process. + * @type {boolean} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + defaultAllowPrivilegeEscalation?: boolean; + /** + * forbiddenSysctls is a list of explicitly forbidden sysctls, defaults to none. Each entry is either a plain sysctl name or ends in \"*\" in which case it is considered as a prefix of forbidden sysctls. Single * means all sysctls are forbidden. Examples: e.g. \"foo/_*\" forbids \"foo/bar\", \"foo/baz\", etc. e.g. \"foo.*\" forbids \"foo.bar\", \"foo.baz\", etc. + * @type {Array} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + forbiddenSysctls?: string[]; + /** + * + * @type {ExtensionsV1beta1FSGroupStrategyOptions} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + fsGroup: ExtensionsV1beta1FSGroupStrategyOptions; + /** + * hostIPC determines if the policy allows the use of HostIPC in the pod spec. + * @type {boolean} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + hostIPC?: boolean; + /** + * hostNetwork determines if the policy allows the use of HostNetwork in the pod spec. + * @type {boolean} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + hostNetwork?: boolean; + /** + * hostPID determines if the policy allows the use of HostPID in the pod spec. + * @type {boolean} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + hostPID?: boolean; + /** + * hostPorts determines which host port ranges are allowed to be exposed. + * @type {Array} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + hostPorts?: ExtensionsV1beta1HostPortRange[]; + /** + * privileged determines if a pod can request to be run as privileged. + * @type {boolean} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + privileged?: boolean; + /** + * readOnlyRootFilesystem when set to true will force containers to run with a read only root file system. If the container specifically requests to run with a non-read only root file system the PSP should deny the pod. If set to false the container may run with a read only root file system if it wishes but it will not be forced to. + * @type {boolean} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + readOnlyRootFilesystem?: boolean; + /** + * requiredDropCapabilities are the capabilities that will be dropped from the container. These are required to be dropped and cannot be added. + * @type {Array} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + requiredDropCapabilities?: string[]; + /** + * + * @type {ExtensionsV1beta1RunAsUserStrategyOptions} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + runAsUser: ExtensionsV1beta1RunAsUserStrategyOptions; + /** + * + * @type {ExtensionsV1beta1SELinuxStrategyOptions} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + seLinux: ExtensionsV1beta1SELinuxStrategyOptions; + /** + * + * @type {ExtensionsV1beta1SupplementalGroupsStrategyOptions} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + supplementalGroups: ExtensionsV1beta1SupplementalGroupsStrategyOptions; + /** + * volumes is a white list of allowed volume plugins. Empty indicates that no volumes may be used. To allow all volumes you may use \'*\'. + * @type {Array} + * @memberof ExtensionsV1beta1PodSecurityPolicySpec + */ + volumes?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSet.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSet.ts new file mode 100644 index 00000000000..7c5e2740063 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSet.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1ReplicaSetSpec } from './ExtensionsV1beta1ReplicaSetSpec'; +import { ExtensionsV1beta1ReplicaSetStatus } from './ExtensionsV1beta1ReplicaSetStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * DEPRECATED - This group version of ReplicaSet is deprecated by apps/v1beta2/ReplicaSet. See the release notes for more information. ReplicaSet ensures that a specified number of pod replicas are running at any given time. + * @export + * @interface ExtensionsV1beta1ReplicaSet + */ +export interface ExtensionsV1beta1ReplicaSet { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1ReplicaSet + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1ReplicaSet + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof ExtensionsV1beta1ReplicaSet + */ + metadata?: V1ObjectMeta; + /** + * + * @type {ExtensionsV1beta1ReplicaSetSpec} + * @memberof ExtensionsV1beta1ReplicaSet + */ + spec?: ExtensionsV1beta1ReplicaSetSpec; + /** + * + * @type {ExtensionsV1beta1ReplicaSetStatus} + * @memberof ExtensionsV1beta1ReplicaSet + */ + status?: ExtensionsV1beta1ReplicaSetStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetCondition.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetCondition.ts new file mode 100644 index 00000000000..1fc58f514dd --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ReplicaSetCondition describes the state of a replica set at a certain point. + * @export + * @interface ExtensionsV1beta1ReplicaSetCondition + */ +export interface ExtensionsV1beta1ReplicaSetCondition { + /** + * + * @type {string} + * @memberof ExtensionsV1beta1ReplicaSetCondition + */ + lastTransitionTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof ExtensionsV1beta1ReplicaSetCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof ExtensionsV1beta1ReplicaSetCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof ExtensionsV1beta1ReplicaSetCondition + */ + status: string; + /** + * Type of replica set condition. + * @type {string} + * @memberof ExtensionsV1beta1ReplicaSetCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetList.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetList.ts new file mode 100644 index 00000000000..886557770ec --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1ReplicaSet } from './ExtensionsV1beta1ReplicaSet'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ReplicaSetList is a collection of ReplicaSets. + * @export + * @interface ExtensionsV1beta1ReplicaSetList + */ +export interface ExtensionsV1beta1ReplicaSetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1ReplicaSetList + */ + apiVersion?: string; + /** + * List of ReplicaSets. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller + * @type {Array} + * @memberof ExtensionsV1beta1ReplicaSetList + */ + items: ExtensionsV1beta1ReplicaSet[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1ReplicaSetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof ExtensionsV1beta1ReplicaSetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetSpec.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetSpec.ts new file mode 100644 index 00000000000..8f7f1f75e66 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetSpec.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * ReplicaSetSpec is the specification of a ReplicaSet. + * @export + * @interface ExtensionsV1beta1ReplicaSetSpec + */ +export interface ExtensionsV1beta1ReplicaSetSpec { + /** + * Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) + * @type {number} + * @memberof ExtensionsV1beta1ReplicaSetSpec + */ + minReadySeconds?: number; + /** + * Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller + * @type {number} + * @memberof ExtensionsV1beta1ReplicaSetSpec + */ + replicas?: number; + /** + * + * @type {V1LabelSelector} + * @memberof ExtensionsV1beta1ReplicaSetSpec + */ + selector?: V1LabelSelector; + /** + * + * @type {V1PodTemplateSpec} + * @memberof ExtensionsV1beta1ReplicaSetSpec + */ + template?: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetStatus.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetStatus.ts new file mode 100644 index 00000000000..818e02c512b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ReplicaSetStatus.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1ReplicaSetCondition } from './ExtensionsV1beta1ReplicaSetCondition'; + +/** + * ReplicaSetStatus represents the current status of a ReplicaSet. + * @export + * @interface ExtensionsV1beta1ReplicaSetStatus + */ +export interface ExtensionsV1beta1ReplicaSetStatus { + /** + * The number of available replicas (ready for at least minReadySeconds) for this replica set. + * @type {number} + * @memberof ExtensionsV1beta1ReplicaSetStatus + */ + availableReplicas?: number; + /** + * Represents the latest available observations of a replica set\'s current state. + * @type {Array} + * @memberof ExtensionsV1beta1ReplicaSetStatus + */ + conditions?: ExtensionsV1beta1ReplicaSetCondition[]; + /** + * The number of pods that have labels matching the labels of the pod template of the replicaset. + * @type {number} + * @memberof ExtensionsV1beta1ReplicaSetStatus + */ + fullyLabeledReplicas?: number; + /** + * ObservedGeneration reflects the generation of the most recently observed ReplicaSet. + * @type {number} + * @memberof ExtensionsV1beta1ReplicaSetStatus + */ + observedGeneration?: number; + /** + * The number of ready replicas for this replica set. + * @type {number} + * @memberof ExtensionsV1beta1ReplicaSetStatus + */ + readyReplicas?: number; + /** + * Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller + * @type {number} + * @memberof ExtensionsV1beta1ReplicaSetStatus + */ + replicas: number; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollbackConfig.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollbackConfig.ts new file mode 100644 index 00000000000..a9923c2c746 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollbackConfig.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DEPRECATED. + * @export + * @interface ExtensionsV1beta1RollbackConfig + */ +export interface ExtensionsV1beta1RollbackConfig { + /** + * The revision to rollback to. If set to 0, rollback to the last revision. + * @type {number} + * @memberof ExtensionsV1beta1RollbackConfig + */ + revision?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollingUpdateDaemonSet.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollingUpdateDaemonSet.ts new file mode 100644 index 00000000000..93cbba4c71b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollingUpdateDaemonSet.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Spec to control the desired behavior of daemon set rolling update. + * @export + * @interface ExtensionsV1beta1RollingUpdateDaemonSet + */ +export interface ExtensionsV1beta1RollingUpdateDaemonSet { + /** + * + * @type {string} + * @memberof ExtensionsV1beta1RollingUpdateDaemonSet + */ + maxUnavailable?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollingUpdateDeployment.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollingUpdateDeployment.ts new file mode 100644 index 00000000000..765c5fc7179 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RollingUpdateDeployment.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Spec to control the desired behavior of rolling update. + * @export + * @interface ExtensionsV1beta1RollingUpdateDeployment + */ +export interface ExtensionsV1beta1RollingUpdateDeployment { + /** + * + * @type {string} + * @memberof ExtensionsV1beta1RollingUpdateDeployment + */ + maxSurge?: string; + /** + * + * @type {string} + * @memberof ExtensionsV1beta1RollingUpdateDeployment + */ + maxUnavailable?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RunAsUserStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RunAsUserStrategyOptions.ts new file mode 100644 index 00000000000..5a16ecba662 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1RunAsUserStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1IDRange } from './ExtensionsV1beta1IDRange'; + +/** + * RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use RunAsUserStrategyOptions from policy API Group instead. + * @export + * @interface ExtensionsV1beta1RunAsUserStrategyOptions + */ +export interface ExtensionsV1beta1RunAsUserStrategyOptions { + /** + * ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs. + * @type {Array} + * @memberof ExtensionsV1beta1RunAsUserStrategyOptions + */ + ranges?: ExtensionsV1beta1IDRange[]; + /** + * rule is the strategy that will dictate the allowable RunAsUser values that may be set. + * @type {string} + * @memberof ExtensionsV1beta1RunAsUserStrategyOptions + */ + rule: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1SELinuxStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1SELinuxStrategyOptions.ts new file mode 100644 index 00000000000..ba28514f227 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1SELinuxStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SELinuxOptions } from './V1SELinuxOptions'; + +/** + * SELinuxStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use SELinuxStrategyOptions from policy API Group instead. + * @export + * @interface ExtensionsV1beta1SELinuxStrategyOptions + */ +export interface ExtensionsV1beta1SELinuxStrategyOptions { + /** + * rule is the strategy that will dictate the allowable labels that may be set. + * @type {string} + * @memberof ExtensionsV1beta1SELinuxStrategyOptions + */ + rule: string; + /** + * + * @type {V1SELinuxOptions} + * @memberof ExtensionsV1beta1SELinuxStrategyOptions + */ + seLinuxOptions?: V1SELinuxOptions; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Scale.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Scale.ts new file mode 100644 index 00000000000..b703628dafe --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1Scale.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1ScaleSpec } from './ExtensionsV1beta1ScaleSpec'; +import { ExtensionsV1beta1ScaleStatus } from './ExtensionsV1beta1ScaleStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * represents a scaling request for a resource. + * @export + * @interface ExtensionsV1beta1Scale + */ +export interface ExtensionsV1beta1Scale { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof ExtensionsV1beta1Scale + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof ExtensionsV1beta1Scale + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof ExtensionsV1beta1Scale + */ + metadata?: V1ObjectMeta; + /** + * + * @type {ExtensionsV1beta1ScaleSpec} + * @memberof ExtensionsV1beta1Scale + */ + spec?: ExtensionsV1beta1ScaleSpec; + /** + * + * @type {ExtensionsV1beta1ScaleStatus} + * @memberof ExtensionsV1beta1Scale + */ + status?: ExtensionsV1beta1ScaleStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ScaleSpec.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ScaleSpec.ts new file mode 100644 index 00000000000..5fa778c5b9c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ScaleSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * describes the attributes of a scale subresource + * @export + * @interface ExtensionsV1beta1ScaleSpec + */ +export interface ExtensionsV1beta1ScaleSpec { + /** + * desired number of instances for the scaled object. + * @type {number} + * @memberof ExtensionsV1beta1ScaleSpec + */ + replicas?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ScaleStatus.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ScaleStatus.ts new file mode 100644 index 00000000000..debafd4e073 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1ScaleStatus.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * represents the current status of a scale subresource. + * @export + * @interface ExtensionsV1beta1ScaleStatus + */ +export interface ExtensionsV1beta1ScaleStatus { + /** + * actual number of observed instances of the scaled object. + * @type {number} + * @memberof ExtensionsV1beta1ScaleStatus + */ + replicas: number; + /** + * label query over pods that should match the replicas count. More info: http://kubernetes.io/docs/user-guide/labels#label-selectors + * @type {{ [key: string]: string; }} + * @memberof ExtensionsV1beta1ScaleStatus + */ + selector?: { [key: string]: string }; + /** + * label selector for pods that should match the replicas count. This is a serializated version of both map-based and more expressive set-based selectors. This is done to avoid introspection in the clients. The string will be in the same format as the query-param syntax. If the target type only supports map-based selectors, both this field and map-based selector field are populated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors + * @type {string} + * @memberof ExtensionsV1beta1ScaleStatus + */ + targetSelector?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1SupplementalGroupsStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1SupplementalGroupsStrategyOptions.ts new file mode 100644 index 00000000000..ef77d57b42f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/ExtensionsV1beta1SupplementalGroupsStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { ExtensionsV1beta1IDRange } from './ExtensionsV1beta1IDRange'; + +/** + * SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy. Deprecated: use SupplementalGroupsStrategyOptions from policy API Group instead. + * @export + * @interface ExtensionsV1beta1SupplementalGroupsStrategyOptions + */ +export interface ExtensionsV1beta1SupplementalGroupsStrategyOptions { + /** + * ranges are the allowed ranges of supplemental groups. If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs. + * @type {Array} + * @memberof ExtensionsV1beta1SupplementalGroupsStrategyOptions + */ + ranges?: ExtensionsV1beta1IDRange[]; + /** + * rule is the strategy that will dictate what supplemental groups is used in the SecurityContext. + * @type {string} + * @memberof ExtensionsV1beta1SupplementalGroupsStrategyOptions + */ + rule?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/IoK8sApimachineryPkgRuntimeRawExtension.ts b/frontend/packages/kube-types/src/openshift/IoK8sApimachineryPkgRuntimeRawExtension.ts new file mode 100644 index 00000000000..af0164dda03 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/IoK8sApimachineryPkgRuntimeRawExtension.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RawExtension is used to hold extensions in external versions. To use this, make a field which has RawExtension as its type in your external, versioned struct, and Object in your internal struct. You also need to register your various plugin types. // Internal package: type MyAPIObject struct { runtime.TypeMeta `json:\",inline\"` MyPlugin runtime.Object `json:\"myPlugin\"` } type PluginA struct { AOption string `json:\"aOption\"` } // External package: type MyAPIObject struct { runtime.TypeMeta `json:\",inline\"` MyPlugin runtime.RawExtension `json:\"myPlugin\"` } type PluginA struct { AOption string `json:\"aOption\"` } // On the wire, the JSON will look something like this: { \"kind\":\"MyAPIObject\", \"apiVersion\":\"v1\", \"myPlugin\": { \"kind\":\"PluginA\", \"aOption\":\"foo\", }, } So what happens? Decode first uses json or yaml to unmarshal the serialized data into your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked. The next step is to copy (using pkg/conversion) into the internal struct. The runtime package\'s DefaultScheme has conversion functions installed which will unpack the JSON stored in RawExtension, turning it into the correct object type, and storing it in the Object. (TODO: In the case where the object is of an unknown type, a runtime.Unknown object will be created and stored.) + * @export + * @interface IoK8sApimachineryPkgRuntimeRawExtension + */ +export interface IoK8sApimachineryPkgRuntimeRawExtension { + /** + * Raw is the underlying serialization of this object. + * @type {string} + * @memberof IoK8sApimachineryPkgRuntimeRawExtension + */ + raw: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1AllowedFlexVolume.ts b/frontend/packages/kube-types/src/openshift/OSV1AllowedFlexVolume.ts new file mode 100644 index 00000000000..7d019ea10a7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1AllowedFlexVolume.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * AllowedFlexVolume represents a single Flexvolume that is allowed to be used. + * @export + * @interface OSV1AllowedFlexVolume + */ +export interface OSV1AllowedFlexVolume { + /** + * Driver is the name of the Flexvolume driver. + * @type {string} + * @memberof OSV1AllowedFlexVolume + */ + driver: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1AppliedClusterResourceQuota.ts b/frontend/packages/kube-types/src/openshift/OSV1AppliedClusterResourceQuota.ts new file mode 100644 index 00000000000..46cda686678 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1AppliedClusterResourceQuota.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ClusterResourceQuotaSpec } from './OSV1ClusterResourceQuotaSpec'; +import { OSV1ClusterResourceQuotaStatus } from './OSV1ClusterResourceQuotaStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * AppliedClusterResourceQuota mirrors ClusterResourceQuota at a project scope, for projection into a project. It allows a project-admin to know which ClusterResourceQuotas are applied to his project and their associated usage. + * @export + * @interface OSV1AppliedClusterResourceQuota + */ +export interface OSV1AppliedClusterResourceQuota { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1AppliedClusterResourceQuota + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1AppliedClusterResourceQuota + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1AppliedClusterResourceQuota + */ + metadata: V1ObjectMeta; + /** + * + * @type {OSV1ClusterResourceQuotaSpec} + * @memberof OSV1AppliedClusterResourceQuota + */ + spec: OSV1ClusterResourceQuotaSpec; + /** + * + * @type {OSV1ClusterResourceQuotaStatus} + * @memberof OSV1AppliedClusterResourceQuota + */ + status?: OSV1ClusterResourceQuotaStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1AppliedClusterResourceQuotaList.ts b/frontend/packages/kube-types/src/openshift/OSV1AppliedClusterResourceQuotaList.ts new file mode 100644 index 00000000000..8f452a8bfa3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1AppliedClusterResourceQuotaList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1AppliedClusterResourceQuota } from './OSV1AppliedClusterResourceQuota'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * AppliedClusterResourceQuotaList is a collection of AppliedClusterResourceQuotas + * @export + * @interface OSV1AppliedClusterResourceQuotaList + */ +export interface OSV1AppliedClusterResourceQuotaList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1AppliedClusterResourceQuotaList + */ + apiVersion?: string; + /** + * Items is a list of AppliedClusterResourceQuota + * @type {Array} + * @memberof OSV1AppliedClusterResourceQuotaList + */ + items: OSV1AppliedClusterResourceQuota[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1AppliedClusterResourceQuotaList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1AppliedClusterResourceQuotaList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BinaryBuildSource.ts b/frontend/packages/kube-types/src/openshift/OSV1BinaryBuildSource.ts new file mode 100644 index 00000000000..c19bdfe1139 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BinaryBuildSource.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * BinaryBuildSource describes a binary file to be used for the Docker and Source build strategies, where the file will be extracted and used as the build source. + * @export + * @interface OSV1BinaryBuildSource + */ +export interface OSV1BinaryBuildSource { + /** + * asFile indicates that the provided binary input should be considered a single file within the build input. For example, specifying \"webapp.war\" would place the provided binary as `/webapp.war` for the builder. If left empty, the Docker and Source build strategies assume this file is a zip, tar, or tar.gz file and extract it as the source. The custom strategy receives this binary as standard input. This filename may not contain slashes or be \'..\' or \'.\'. + * @type {string} + * @memberof OSV1BinaryBuildSource + */ + asFile?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BitbucketWebHookCause.ts b/frontend/packages/kube-types/src/openshift/OSV1BitbucketWebHookCause.ts new file mode 100644 index 00000000000..8cd2c4e7998 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BitbucketWebHookCause.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1SourceRevision } from './OSV1SourceRevision'; + +/** + * BitbucketWebHookCause has information about a Bitbucket webhook that triggered a build. + * @export + * @interface OSV1BitbucketWebHookCause + */ +export interface OSV1BitbucketWebHookCause { + /** + * + * @type {OSV1SourceRevision} + * @memberof OSV1BitbucketWebHookCause + */ + revision?: OSV1SourceRevision; + /** + * Secret is the obfuscated webhook secret that triggered a build. + * @type {string} + * @memberof OSV1BitbucketWebHookCause + */ + secret?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1Build.ts b/frontend/packages/kube-types/src/openshift/OSV1Build.ts new file mode 100644 index 00000000000..8ecfc677caa --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1Build.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1BuildSpec } from './OSV1BuildSpec'; +import { OSV1BuildStatus } from './OSV1BuildStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Build encapsulates the inputs needed to produce a new deployable image, as well as the status of the execution and a reference to the Pod which executed the build. + * @export + * @interface OSV1Build + */ +export interface OSV1Build { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1Build + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1Build + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1Build + */ + metadata?: V1ObjectMeta; + /** + * + * @type {OSV1BuildSpec} + * @memberof OSV1Build + */ + spec?: OSV1BuildSpec; + /** + * + * @type {OSV1BuildStatus} + * @memberof OSV1Build + */ + status?: OSV1BuildStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildConfig.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildConfig.ts new file mode 100644 index 00000000000..7f82b1f211a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildConfig.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1BuildConfigSpec } from './OSV1BuildConfigSpec'; +import { OSV1BuildConfigStatus } from './OSV1BuildConfigStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Build configurations define a build process for new container images. There are three types of builds possible - a container image build using a Dockerfile, a Source-to-Image build that uses a specially prepared base image that accepts source code that it can make runnable, and a custom build that can run // arbitrary container images as a base and accept the build parameters. Builds run on the cluster and on completion are pushed to the container image registry specified in the \"output\" section. A build can be triggered via a webhook, when the base image changes, or when a user manually requests a new build be // created. Each build created by a build configuration is numbered and refers back to its parent configuration. Multiple builds can be triggered at once. Builds that do not have \"output\" set can be used to test code or run a verification build. + * @export + * @interface OSV1BuildConfig + */ +export interface OSV1BuildConfig { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1BuildConfig + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1BuildConfig + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1BuildConfig + */ + metadata?: V1ObjectMeta; + /** + * + * @type {OSV1BuildConfigSpec} + * @memberof OSV1BuildConfig + */ + spec: OSV1BuildConfigSpec; + /** + * + * @type {OSV1BuildConfigStatus} + * @memberof OSV1BuildConfig + */ + status: OSV1BuildConfigStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildConfigList.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildConfigList.ts new file mode 100644 index 00000000000..72a76b33118 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildConfigList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1BuildConfig } from './OSV1BuildConfig'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * BuildConfigList is a collection of BuildConfigs. + * @export + * @interface OSV1BuildConfigList + */ +export interface OSV1BuildConfigList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1BuildConfigList + */ + apiVersion?: string; + /** + * items is a list of build configs + * @type {Array} + * @memberof OSV1BuildConfigList + */ + items: OSV1BuildConfig[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1BuildConfigList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1BuildConfigList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildConfigSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildConfigSpec.ts new file mode 100644 index 00000000000..69af705f53d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildConfigSpec.ts @@ -0,0 +1,106 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1BuildOutput } from './OSV1BuildOutput'; +import { OSV1BuildPostCommitSpec } from './OSV1BuildPostCommitSpec'; +import { OSV1BuildSource } from './OSV1BuildSource'; +import { OSV1BuildStrategy } from './OSV1BuildStrategy'; +import { OSV1BuildTriggerPolicy } from './OSV1BuildTriggerPolicy'; +import { OSV1SourceRevision } from './OSV1SourceRevision'; +import { V1ResourceRequirements } from './V1ResourceRequirements'; + +/** + * BuildConfigSpec describes when and how builds are created + * @export + * @interface OSV1BuildConfigSpec + */ +export interface OSV1BuildConfigSpec { + /** + * completionDeadlineSeconds is an optional duration in seconds, counted from the time when a build pod gets scheduled in the system, that the build may be active on a node before the system actively tries to terminate the build; value must be positive integer + * @type {number} + * @memberof OSV1BuildConfigSpec + */ + completionDeadlineSeconds?: number; + /** + * failedBuildsHistoryLimit is the number of old failed builds to retain. If not specified, all failed builds are retained. + * @type {number} + * @memberof OSV1BuildConfigSpec + */ + failedBuildsHistoryLimit?: number; + /** + * nodeSelector is a selector which must be true for the build pod to fit on a node If nil, it can be overridden by default build nodeselector values for the cluster. If set to an empty map or a map with any values, default build nodeselector values are ignored. + * @type {{ [key: string]: string; }} + * @memberof OSV1BuildConfigSpec + */ + nodeSelector: { [key: string]: string }; + /** + * + * @type {OSV1BuildOutput} + * @memberof OSV1BuildConfigSpec + */ + output?: OSV1BuildOutput; + /** + * + * @type {OSV1BuildPostCommitSpec} + * @memberof OSV1BuildConfigSpec + */ + postCommit?: OSV1BuildPostCommitSpec; + /** + * + * @type {V1ResourceRequirements} + * @memberof OSV1BuildConfigSpec + */ + resources?: V1ResourceRequirements; + /** + * + * @type {OSV1SourceRevision} + * @memberof OSV1BuildConfigSpec + */ + revision?: OSV1SourceRevision; + /** + * RunPolicy describes how the new build created from this build configuration will be scheduled for execution. This is optional, if not specified we default to \"Serial\". + * @type {string} + * @memberof OSV1BuildConfigSpec + */ + runPolicy?: string; + /** + * serviceAccount is the name of the ServiceAccount to use to run the pod created by this build. The pod will be allowed to use secrets referenced by the ServiceAccount + * @type {string} + * @memberof OSV1BuildConfigSpec + */ + serviceAccount?: string; + /** + * + * @type {OSV1BuildSource} + * @memberof OSV1BuildConfigSpec + */ + source?: OSV1BuildSource; + /** + * + * @type {OSV1BuildStrategy} + * @memberof OSV1BuildConfigSpec + */ + strategy: OSV1BuildStrategy; + /** + * successfulBuildsHistoryLimit is the number of old successful builds to retain. If not specified, all successful builds are retained. + * @type {number} + * @memberof OSV1BuildConfigSpec + */ + successfulBuildsHistoryLimit?: number; + /** + * triggers determine how new Builds can be launched from a BuildConfig. If no triggers are defined, a new build can only occur as a result of an explicit client build creation. + * @type {Array} + * @memberof OSV1BuildConfigSpec + */ + triggers: OSV1BuildTriggerPolicy[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildConfigStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildConfigStatus.ts new file mode 100644 index 00000000000..e3119c592c1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildConfigStatus.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * BuildConfigStatus contains current state of the build config object. + * @export + * @interface OSV1BuildConfigStatus + */ +export interface OSV1BuildConfigStatus { + /** + * lastVersion is used to inform about number of last triggered build. + * @type {number} + * @memberof OSV1BuildConfigStatus + */ + lastVersion: number; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildList.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildList.ts new file mode 100644 index 00000000000..524e88d0c89 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1Build } from './OSV1Build'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * BuildList is a collection of Builds. + * @export + * @interface OSV1BuildList + */ +export interface OSV1BuildList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1BuildList + */ + apiVersion?: string; + /** + * items is a list of builds + * @type {Array} + * @memberof OSV1BuildList + */ + items: OSV1Build[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1BuildList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1BuildList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildLog.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildLog.ts new file mode 100644 index 00000000000..3ba4cdc8fcf --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildLog.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * BuildLog is the (unused) resource associated with the build log redirector + * @export + * @interface OSV1BuildLog + */ +export interface OSV1BuildLog { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1BuildLog + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1BuildLog + */ + kind?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildOutput.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildOutput.ts new file mode 100644 index 00000000000..d401bb684d7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildOutput.ts @@ -0,0 +1,42 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageLabel } from './OSV1ImageLabel'; +import { V1LocalObjectReference } from './V1LocalObjectReference'; +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * BuildOutput is input to a build strategy and describes the container image that the strategy should produce. + * @export + * @interface OSV1BuildOutput + */ +export interface OSV1BuildOutput { + /** + * imageLabels define a list of labels that are applied to the resulting image. If there are multiple labels with the same name then the last one in the list is used. + * @type {Array} + * @memberof OSV1BuildOutput + */ + imageLabels?: OSV1ImageLabel[]; + /** + * + * @type {V1LocalObjectReference} + * @memberof OSV1BuildOutput + */ + pushSecret?: V1LocalObjectReference; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1BuildOutput + */ + to?: V1ObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildPostCommitSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildPostCommitSpec.ts new file mode 100644 index 00000000000..51ab23fd33a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildPostCommitSpec.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * A BuildPostCommitSpec holds a build post commit hook specification. The hook executes a command in a temporary container running the build output image, immediately after the last layer of the image is committed and before the image is pushed to a registry. The command is executed with the current working directory ($PWD) set to the image\'s WORKDIR. The build will be marked as failed if the hook execution fails. It will fail if the script or command return a non-zero exit code, or if there is any other error related to starting the temporary container. There are five different ways to configure the hook. As an example, all forms below are equivalent and will execute `rake test --verbose`. 1. Shell script: \"postCommit\": { \"script\": \"rake test --verbose\", } The above is a convenient form which is equivalent to: \"postCommit\": { \"command\": [\"/bin/sh\", \"-ic\"], \"args\": [\"rake test --verbose\"] } 2. A command as the image entrypoint: \"postCommit\": { \"commit\": [\"rake\", \"test\", \"--verbose\"] } Command overrides the image entrypoint in the exec form, as documented in Docker: https://docs.docker.com/engine/reference/builder/#entrypoint. 3. Pass arguments to the default entrypoint: \"postCommit\": { \"args\": [\"rake\", \"test\", \"--verbose\"] } This form is only useful if the image entrypoint can handle arguments. 4. Shell script with arguments: \"postCommit\": { \"script\": \"rake test $1\", \"args\": [\"--verbose\"] } This form is useful if you need to pass arguments that would otherwise be hard to quote properly in the shell script. In the script, $0 will be \"/bin/sh\" and $1, $2, etc, are the positional arguments from Args. 5. Command with arguments: \"postCommit\": { \"command\": [\"rake\", \"test\"], \"args\": [\"--verbose\"] } This form is equivalent to appending the arguments to the Command slice. It is invalid to provide both Script and Command simultaneously. If none of the fields are specified, the hook is not executed. + * @export + * @interface OSV1BuildPostCommitSpec + */ +export interface OSV1BuildPostCommitSpec { + /** + * args is a list of arguments that are provided to either Command, Script or the container image\'s default entrypoint. The arguments are placed immediately after the command to be run. + * @type {Array} + * @memberof OSV1BuildPostCommitSpec + */ + args?: string[]; + /** + * command is the command to run. It may not be specified with Script. This might be needed if the image doesn\'t have `/bin/sh`, or if you do not want to use a shell. In all other cases, using Script might be more convenient. + * @type {Array} + * @memberof OSV1BuildPostCommitSpec + */ + command?: string[]; + /** + * script is a shell script to be run with `/bin/sh -ic`. It may not be specified with Command. Use Script when a shell script is appropriate to execute the post build hook, for example for running unit tests with `rake test`. If you need control over the image entrypoint, or if the image does not have `/bin/sh`, use Command and/or Args. The `-i` flag is needed to support CentOS and RHEL images that use Software Collections (SCL), in order to have the appropriate collections enabled in the shell. E.g., in the Ruby image, this is necessary to make `ruby`, `bundle` and other binaries available in the PATH. + * @type {string} + * @memberof OSV1BuildPostCommitSpec + */ + script?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildRequest.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildRequest.ts new file mode 100644 index 00000000000..28ab559ba73 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildRequest.ts @@ -0,0 +1,101 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1BinaryBuildSource } from './OSV1BinaryBuildSource'; +import { OSV1BuildTriggerCause } from './OSV1BuildTriggerCause'; +import { OSV1DockerStrategyOptions } from './OSV1DockerStrategyOptions'; +import { OSV1SourceRevision } from './OSV1SourceRevision'; +import { OSV1SourceStrategyOptions } from './OSV1SourceStrategyOptions'; +import { V1EnvVar } from './V1EnvVar'; +import { V1ObjectReference } from './V1ObjectReference'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * BuildRequest is the resource used to pass parameters to build generator + * @export + * @interface OSV1BuildRequest + */ +export interface OSV1BuildRequest { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1BuildRequest + */ + apiVersion?: string; + /** + * + * @type {OSV1BinaryBuildSource} + * @memberof OSV1BuildRequest + */ + binary?: OSV1BinaryBuildSource; + /** + * + * @type {OSV1DockerStrategyOptions} + * @memberof OSV1BuildRequest + */ + dockerStrategyOptions?: OSV1DockerStrategyOptions; + /** + * env contains additional environment variables you want to pass into a builder container. + * @type {Array} + * @memberof OSV1BuildRequest + */ + env?: V1EnvVar[]; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1BuildRequest + */ + from?: V1ObjectReference; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1BuildRequest + */ + kind?: string; + /** + * lastVersion (optional) is the LastVersion of the BuildConfig that was used to generate the build. If the BuildConfig in the generator doesn\'t match, a build will not be generated. + * @type {number} + * @memberof OSV1BuildRequest + */ + lastVersion?: number; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1BuildRequest + */ + metadata?: V1ObjectMeta; + /** + * + * @type {OSV1SourceRevision} + * @memberof OSV1BuildRequest + */ + revision?: OSV1SourceRevision; + /** + * + * @type {OSV1SourceStrategyOptions} + * @memberof OSV1BuildRequest + */ + sourceStrategyOptions?: OSV1SourceStrategyOptions; + /** + * triggeredBy describes which triggers started the most recent update to the build configuration and contains information about those triggers. + * @type {Array} + * @memberof OSV1BuildRequest + */ + triggeredBy: OSV1BuildTriggerCause[]; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1BuildRequest + */ + triggeredByImage?: V1ObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildSource.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildSource.ts new file mode 100644 index 00000000000..be6a83f3477 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildSource.ts @@ -0,0 +1,81 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1BinaryBuildSource } from './OSV1BinaryBuildSource'; +import { OSV1ConfigMapBuildSource } from './OSV1ConfigMapBuildSource'; +import { OSV1GitBuildSource } from './OSV1GitBuildSource'; +import { OSV1ImageSource } from './OSV1ImageSource'; +import { OSV1SecretBuildSource } from './OSV1SecretBuildSource'; +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * BuildSource is the SCM used for the build. + * @export + * @interface OSV1BuildSource + */ +export interface OSV1BuildSource { + /** + * + * @type {OSV1BinaryBuildSource} + * @memberof OSV1BuildSource + */ + binary?: OSV1BinaryBuildSource; + /** + * configMaps represents a list of configMaps and their destinations that will be used for the build. + * @type {Array} + * @memberof OSV1BuildSource + */ + configMaps?: OSV1ConfigMapBuildSource[]; + /** + * contextDir specifies the sub-directory where the source code for the application exists. This allows to have buildable sources in directory other than root of repository. + * @type {string} + * @memberof OSV1BuildSource + */ + contextDir?: string; + /** + * dockerfile is the raw contents of a Dockerfile which should be built. When this option is specified, the FROM may be modified based on your strategy base image and additional ENV stanzas from your strategy environment will be added after the FROM, but before the rest of your Dockerfile stanzas. The Dockerfile source type may be used with other options like git - in those cases the Git repo will have any innate Dockerfile replaced in the context dir. + * @type {string} + * @memberof OSV1BuildSource + */ + dockerfile?: string; + /** + * + * @type {OSV1GitBuildSource} + * @memberof OSV1BuildSource + */ + git?: OSV1GitBuildSource; + /** + * images describes a set of images to be used to provide source for the build + * @type {Array} + * @memberof OSV1BuildSource + */ + images?: OSV1ImageSource[]; + /** + * secrets represents a list of secrets and their destinations that will be used only for the build. + * @type {Array} + * @memberof OSV1BuildSource + */ + secrets?: OSV1SecretBuildSource[]; + /** + * + * @type {V1LocalObjectReference} + * @memberof OSV1BuildSource + */ + sourceSecret?: V1LocalObjectReference; + /** + * type of build input to accept + * @type {string} + * @memberof OSV1BuildSource + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildSpec.ts new file mode 100644 index 00000000000..1bd5c50d2a1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildSpec.ts @@ -0,0 +1,88 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1BuildOutput } from './OSV1BuildOutput'; +import { OSV1BuildPostCommitSpec } from './OSV1BuildPostCommitSpec'; +import { OSV1BuildSource } from './OSV1BuildSource'; +import { OSV1BuildStrategy } from './OSV1BuildStrategy'; +import { OSV1BuildTriggerCause } from './OSV1BuildTriggerCause'; +import { OSV1SourceRevision } from './OSV1SourceRevision'; +import { V1ResourceRequirements } from './V1ResourceRequirements'; + +/** + * BuildSpec has the information to represent a build and also additional information about a build + * @export + * @interface OSV1BuildSpec + */ +export interface OSV1BuildSpec { + /** + * completionDeadlineSeconds is an optional duration in seconds, counted from the time when a build pod gets scheduled in the system, that the build may be active on a node before the system actively tries to terminate the build; value must be positive integer + * @type {number} + * @memberof OSV1BuildSpec + */ + completionDeadlineSeconds?: number; + /** + * nodeSelector is a selector which must be true for the build pod to fit on a node If nil, it can be overridden by default build nodeselector values for the cluster. If set to an empty map or a map with any values, default build nodeselector values are ignored. + * @type {{ [key: string]: string; }} + * @memberof OSV1BuildSpec + */ + nodeSelector: { [key: string]: string }; + /** + * + * @type {OSV1BuildOutput} + * @memberof OSV1BuildSpec + */ + output?: OSV1BuildOutput; + /** + * + * @type {OSV1BuildPostCommitSpec} + * @memberof OSV1BuildSpec + */ + postCommit?: OSV1BuildPostCommitSpec; + /** + * + * @type {V1ResourceRequirements} + * @memberof OSV1BuildSpec + */ + resources?: V1ResourceRequirements; + /** + * + * @type {OSV1SourceRevision} + * @memberof OSV1BuildSpec + */ + revision?: OSV1SourceRevision; + /** + * serviceAccount is the name of the ServiceAccount to use to run the pod created by this build. The pod will be allowed to use secrets referenced by the ServiceAccount + * @type {string} + * @memberof OSV1BuildSpec + */ + serviceAccount?: string; + /** + * + * @type {OSV1BuildSource} + * @memberof OSV1BuildSpec + */ + source?: OSV1BuildSource; + /** + * + * @type {OSV1BuildStrategy} + * @memberof OSV1BuildSpec + */ + strategy: OSV1BuildStrategy; + /** + * triggeredBy describes which triggers started the most recent update to the build configuration and contains information about those triggers. + * @type {Array} + * @memberof OSV1BuildSpec + */ + triggeredBy: OSV1BuildTriggerCause[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildStatus.ts new file mode 100644 index 00000000000..1799436f41b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildStatus.ts @@ -0,0 +1,96 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1BuildStatusOutput } from './OSV1BuildStatusOutput'; +import { OSV1StageInfo } from './OSV1StageInfo'; +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * BuildStatus contains the status of a build + * @export + * @interface OSV1BuildStatus + */ +export interface OSV1BuildStatus { + /** + * cancelled describes if a cancel event was triggered for the build. + * @type {boolean} + * @memberof OSV1BuildStatus + */ + cancelled?: boolean; + /** + * + * @type {string} + * @memberof OSV1BuildStatus + */ + completionTimestamp?: string; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1BuildStatus + */ + config?: V1ObjectReference; + /** + * duration contains time.Duration object describing build time. + * @type {number} + * @memberof OSV1BuildStatus + */ + duration?: number; + /** + * logSnippet is the last few lines of the build log. This value is only set for builds that failed. + * @type {string} + * @memberof OSV1BuildStatus + */ + logSnippet?: string; + /** + * message is a human-readable message indicating details about why the build has this status. + * @type {string} + * @memberof OSV1BuildStatus + */ + message?: string; + /** + * + * @type {OSV1BuildStatusOutput} + * @memberof OSV1BuildStatus + */ + output?: OSV1BuildStatusOutput; + /** + * outputDockerImageReference contains a reference to the container image that will be built by this build. Its value is computed from Build.Spec.Output.To, and should include the registry address, so that it can be used to push and pull the image. + * @type {string} + * @memberof OSV1BuildStatus + */ + outputDockerImageReference?: string; + /** + * phase is the point in the build lifecycle. Possible values are \"New\", \"Pending\", \"Running\", \"Complete\", \"Failed\", \"Error\", and \"Cancelled\". + * @type {string} + * @memberof OSV1BuildStatus + */ + phase: string; + /** + * reason is a brief CamelCase string that describes any failure and is meant for machine parsing and tidy display in the CLI. + * @type {string} + * @memberof OSV1BuildStatus + */ + reason?: string; + /** + * stages contains details about each stage that occurs during the build including start time, duration (in milliseconds), and the steps that occured within each stage. + * @type {Array} + * @memberof OSV1BuildStatus + */ + stages?: OSV1StageInfo[]; + /** + * + * @type {string} + * @memberof OSV1BuildStatus + */ + startTimestamp?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildStatusOutput.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildStatusOutput.ts new file mode 100644 index 00000000000..f3daf44df97 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildStatusOutput.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1BuildStatusOutputTo } from './OSV1BuildStatusOutputTo'; + +/** + * BuildStatusOutput contains the status of the built image. + * @export + * @interface OSV1BuildStatusOutput + */ +export interface OSV1BuildStatusOutput { + /** + * + * @type {OSV1BuildStatusOutputTo} + * @memberof OSV1BuildStatusOutput + */ + to?: OSV1BuildStatusOutputTo; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildStatusOutputTo.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildStatusOutputTo.ts new file mode 100644 index 00000000000..78663d7f0de --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildStatusOutputTo.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * BuildStatusOutputTo describes the status of the built image with regards to image registry to which it was supposed to be pushed. + * @export + * @interface OSV1BuildStatusOutputTo + */ +export interface OSV1BuildStatusOutputTo { + /** + * imageDigest is the digest of the built container image. The digest uniquely identifies the image in the registry to which it was pushed. Please note that this field may not always be set even if the push completes successfully - e.g. when the registry returns no digest or returns it in a format that the builder doesn\'t understand. + * @type {string} + * @memberof OSV1BuildStatusOutputTo + */ + imageDigest?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildStrategy.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildStrategy.ts new file mode 100644 index 00000000000..f39b1ed63b2 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildStrategy.ts @@ -0,0 +1,55 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1CustomBuildStrategy } from './OSV1CustomBuildStrategy'; +import { OSV1DockerBuildStrategy } from './OSV1DockerBuildStrategy'; +import { OSV1JenkinsPipelineBuildStrategy } from './OSV1JenkinsPipelineBuildStrategy'; +import { OSV1SourceBuildStrategy } from './OSV1SourceBuildStrategy'; + +/** + * BuildStrategy contains the details of how to perform a build. + * @export + * @interface OSV1BuildStrategy + */ +export interface OSV1BuildStrategy { + /** + * + * @type {OSV1CustomBuildStrategy} + * @memberof OSV1BuildStrategy + */ + customStrategy?: OSV1CustomBuildStrategy; + /** + * + * @type {OSV1DockerBuildStrategy} + * @memberof OSV1BuildStrategy + */ + dockerStrategy?: OSV1DockerBuildStrategy; + /** + * + * @type {OSV1JenkinsPipelineBuildStrategy} + * @memberof OSV1BuildStrategy + */ + jenkinsPipelineStrategy?: OSV1JenkinsPipelineBuildStrategy; + /** + * + * @type {OSV1SourceBuildStrategy} + * @memberof OSV1BuildStrategy + */ + sourceStrategy?: OSV1SourceBuildStrategy; + /** + * type is the kind of build strategy. + * @type {string} + * @memberof OSV1BuildStrategy + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildTriggerCause.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildTriggerCause.ts new file mode 100644 index 00000000000..7d11d20a14a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildTriggerCause.ts @@ -0,0 +1,62 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1BitbucketWebHookCause } from './OSV1BitbucketWebHookCause'; +import { OSV1GenericWebHookCause } from './OSV1GenericWebHookCause'; +import { OSV1GitHubWebHookCause } from './OSV1GitHubWebHookCause'; +import { OSV1GitLabWebHookCause } from './OSV1GitLabWebHookCause'; +import { OSV1ImageChangeCause } from './OSV1ImageChangeCause'; + +/** + * BuildTriggerCause holds information about a triggered build. It is used for displaying build trigger data for each build and build configuration in oc describe. It is also used to describe which triggers led to the most recent update in the build configuration. + * @export + * @interface OSV1BuildTriggerCause + */ +export interface OSV1BuildTriggerCause { + /** + * + * @type {OSV1BitbucketWebHookCause} + * @memberof OSV1BuildTriggerCause + */ + bitbucketWebHook?: OSV1BitbucketWebHookCause; + /** + * + * @type {OSV1GenericWebHookCause} + * @memberof OSV1BuildTriggerCause + */ + genericWebHook?: OSV1GenericWebHookCause; + /** + * + * @type {OSV1GitHubWebHookCause} + * @memberof OSV1BuildTriggerCause + */ + githubWebHook?: OSV1GitHubWebHookCause; + /** + * + * @type {OSV1GitLabWebHookCause} + * @memberof OSV1BuildTriggerCause + */ + gitlabWebHook?: OSV1GitLabWebHookCause; + /** + * + * @type {OSV1ImageChangeCause} + * @memberof OSV1BuildTriggerCause + */ + imageChangeBuild?: OSV1ImageChangeCause; + /** + * message is used to store a human readable message for why the build was triggered. E.g.: \"Manually triggered by user\", \"Configuration change\",etc. + * @type {string} + * @memberof OSV1BuildTriggerCause + */ + message?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1BuildTriggerPolicy.ts b/frontend/packages/kube-types/src/openshift/OSV1BuildTriggerPolicy.ts new file mode 100644 index 00000000000..55a34d9cab8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1BuildTriggerPolicy.ts @@ -0,0 +1,59 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageChangeTrigger } from './OSV1ImageChangeTrigger'; +import { OSV1WebHookTrigger } from './OSV1WebHookTrigger'; + +/** + * BuildTriggerPolicy describes a policy for a single trigger that results in a new Build. + * @export + * @interface OSV1BuildTriggerPolicy + */ +export interface OSV1BuildTriggerPolicy { + /** + * + * @type {OSV1WebHookTrigger} + * @memberof OSV1BuildTriggerPolicy + */ + bitbucket?: OSV1WebHookTrigger; + /** + * + * @type {OSV1WebHookTrigger} + * @memberof OSV1BuildTriggerPolicy + */ + generic?: OSV1WebHookTrigger; + /** + * + * @type {OSV1WebHookTrigger} + * @memberof OSV1BuildTriggerPolicy + */ + github?: OSV1WebHookTrigger; + /** + * + * @type {OSV1WebHookTrigger} + * @memberof OSV1BuildTriggerPolicy + */ + gitlab?: OSV1WebHookTrigger; + /** + * + * @type {OSV1ImageChangeTrigger} + * @memberof OSV1BuildTriggerPolicy + */ + imageChange?: OSV1ImageChangeTrigger; + /** + * type is the type of build trigger + * @type {string} + * @memberof OSV1BuildTriggerPolicy + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterNetwork.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterNetwork.ts new file mode 100644 index 00000000000..726f0729986 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterNetwork.ts @@ -0,0 +1,77 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ClusterNetworkEntry } from './OSV1ClusterNetworkEntry'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ClusterNetwork describes the cluster network. There is normally only one object of this type, named \"default\", which is created by the SDN network plugin based on the master configuration when the cluster is brought up for the first time. + * @export + * @interface OSV1ClusterNetwork + */ +export interface OSV1ClusterNetwork { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ClusterNetwork + */ + apiVersion?: string; + /** + * ClusterNetworks is a list of ClusterNetwork objects that defines the global overlay network\'s L3 space by specifying a set of CIDR and netmasks that the SDN can allocate addressed from. + * @type {Array} + * @memberof OSV1ClusterNetwork + */ + clusterNetworks: OSV1ClusterNetworkEntry[]; + /** + * HostSubnetLength is the number of bits of network to allocate to each node. eg, 8 would mean that each node would have a /24 slice of the overlay network for its pods + * @type {number} + * @memberof OSV1ClusterNetwork + */ + hostsubnetlength?: number; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ClusterNetwork + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1ClusterNetwork + */ + metadata?: V1ObjectMeta; + /** + * Network is a CIDR string specifying the global overlay network\'s L3 space + * @type {string} + * @memberof OSV1ClusterNetwork + */ + network?: string; + /** + * PluginName is the name of the network plugin being used + * @type {string} + * @memberof OSV1ClusterNetwork + */ + pluginName?: string; + /** + * ServiceNetwork is the CIDR range that Service IP addresses are allocated from + * @type {string} + * @memberof OSV1ClusterNetwork + */ + serviceNetwork: string; + /** + * VXLANPort sets the VXLAN destination port used by the cluster. It is set by the master configuration file on startup and cannot be edited manually. Valid values for VXLANPort are integers 1-65535 inclusive and if unset defaults to 4789. Changing VXLANPort allows users to resolve issues between openshift SDN and other software trying to use the same VXLAN destination port. + * @type {number} + * @memberof OSV1ClusterNetwork + */ + vxlanPort?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterNetworkEntry.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterNetworkEntry.ts new file mode 100644 index 00000000000..15418191dff --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterNetworkEntry.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ClusterNetworkEntry defines an individual cluster network. The CIDRs cannot overlap with other cluster network CIDRs, CIDRs reserved for external ips, CIDRs reserved for service networks, and CIDRs reserved for ingress ips. + * @export + * @interface OSV1ClusterNetworkEntry + */ +export interface OSV1ClusterNetworkEntry { + /** + * CIDR defines the total range of a cluster networks address space. + * @type {string} + * @memberof OSV1ClusterNetworkEntry + */ + CIDR: string; + /** + * HostSubnetLength is the number of bits of the accompanying CIDR address to allocate to each node. eg, 8 would mean that each node would have a /24 slice of the overlay network for its pods. + * @type {number} + * @memberof OSV1ClusterNetworkEntry + */ + hostSubnetLength: number; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterNetworkList.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterNetworkList.ts new file mode 100644 index 00000000000..e2132a63f8a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterNetworkList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ClusterNetwork } from './OSV1ClusterNetwork'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ClusterNetworkList is a collection of ClusterNetworks + * @export + * @interface OSV1ClusterNetworkList + */ +export interface OSV1ClusterNetworkList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ClusterNetworkList + */ + apiVersion?: string; + /** + * Items is the list of cluster networks + * @type {Array} + * @memberof OSV1ClusterNetworkList + */ + items: OSV1ClusterNetwork[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ClusterNetworkList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1ClusterNetworkList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuota.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuota.ts new file mode 100644 index 00000000000..9fca38d78eb --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuota.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ClusterResourceQuotaSpec } from './OSV1ClusterResourceQuotaSpec'; +import { OSV1ClusterResourceQuotaStatus } from './OSV1ClusterResourceQuotaStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ClusterResourceQuota mirrors ResourceQuota at a cluster scope. This object is easily convertible to synthetic ResourceQuota object to allow quota evaluation re-use. + * @export + * @interface OSV1ClusterResourceQuota + */ +export interface OSV1ClusterResourceQuota { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ClusterResourceQuota + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ClusterResourceQuota + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1ClusterResourceQuota + */ + metadata: V1ObjectMeta; + /** + * + * @type {OSV1ClusterResourceQuotaSpec} + * @memberof OSV1ClusterResourceQuota + */ + spec: OSV1ClusterResourceQuotaSpec; + /** + * + * @type {OSV1ClusterResourceQuotaStatus} + * @memberof OSV1ClusterResourceQuota + */ + status?: OSV1ClusterResourceQuotaStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaList.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaList.ts new file mode 100644 index 00000000000..f031d7e9cf3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ClusterResourceQuota } from './OSV1ClusterResourceQuota'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ClusterResourceQuotaList is a collection of ClusterResourceQuotas + * @export + * @interface OSV1ClusterResourceQuotaList + */ +export interface OSV1ClusterResourceQuotaList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ClusterResourceQuotaList + */ + apiVersion?: string; + /** + * Items is a list of ClusterResourceQuotas + * @type {Array} + * @memberof OSV1ClusterResourceQuotaList + */ + items: OSV1ClusterResourceQuota[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ClusterResourceQuotaList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1ClusterResourceQuotaList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaSelector.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaSelector.ts new file mode 100644 index 00000000000..49561e5f5ff --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaSelector.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * ClusterResourceQuotaSelector is used to select projects. At least one of LabelSelector or AnnotationSelector must present. If only one is present, it is the only selection criteria. If both are specified, the project must match both restrictions. + * @export + * @interface OSV1ClusterResourceQuotaSelector + */ +export interface OSV1ClusterResourceQuotaSelector { + /** + * AnnotationSelector is used to select projects by annotation. + * @type {{ [key: string]: string; }} + * @memberof OSV1ClusterResourceQuotaSelector + */ + annotations: { [key: string]: string }; + /** + * + * @type {V1LabelSelector} + * @memberof OSV1ClusterResourceQuotaSelector + */ + labels: V1LabelSelector; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaSpec.ts new file mode 100644 index 00000000000..087e53d5f75 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaSpec.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ClusterResourceQuotaSelector } from './OSV1ClusterResourceQuotaSelector'; +import { V1ResourceQuotaSpec } from './V1ResourceQuotaSpec'; + +/** + * ClusterResourceQuotaSpec defines the desired quota restrictions + * @export + * @interface OSV1ClusterResourceQuotaSpec + */ +export interface OSV1ClusterResourceQuotaSpec { + /** + * + * @type {V1ResourceQuotaSpec} + * @memberof OSV1ClusterResourceQuotaSpec + */ + quota: V1ResourceQuotaSpec; + /** + * + * @type {OSV1ClusterResourceQuotaSelector} + * @memberof OSV1ClusterResourceQuotaSpec + */ + selector: OSV1ClusterResourceQuotaSelector; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaStatus.ts new file mode 100644 index 00000000000..dc214eec201 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterResourceQuotaStatus.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ResourceQuotaStatusByNamespace } from './OSV1ResourceQuotaStatusByNamespace'; +import { V1ResourceQuotaStatus } from './V1ResourceQuotaStatus'; + +/** + * ClusterResourceQuotaStatus defines the actual enforced quota and its current usage + * @export + * @interface OSV1ClusterResourceQuotaStatus + */ +export interface OSV1ClusterResourceQuotaStatus { + /** + * Namespaces slices the usage by project. This division allows for quick resolution of deletion reconciliation inside of a single project without requiring a recalculation across all projects. This can be used to pull the deltas for a given project. + * @type {Array} + * @memberof OSV1ClusterResourceQuotaStatus + */ + namespaces: OSV1ResourceQuotaStatusByNamespace[]; + /** + * + * @type {V1ResourceQuotaStatus} + * @memberof OSV1ClusterResourceQuotaStatus + */ + total: V1ResourceQuotaStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterRole.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterRole.ts new file mode 100644 index 00000000000..f2b62bea982 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterRole.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1PolicyRule } from './OSV1PolicyRule'; +import { V1AggregationRule } from './V1AggregationRule'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ClusterRole is a logical grouping of PolicyRules that can be referenced as a unit by ClusterRoleBindings. + * @export + * @interface OSV1ClusterRole + */ +export interface OSV1ClusterRole { + /** + * + * @type {V1AggregationRule} + * @memberof OSV1ClusterRole + */ + aggregationRule?: V1AggregationRule; + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ClusterRole + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ClusterRole + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1ClusterRole + */ + metadata?: V1ObjectMeta; + /** + * Rules holds all the PolicyRules for this ClusterRole + * @type {Array} + * @memberof OSV1ClusterRole + */ + rules: OSV1PolicyRule[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleBinding.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleBinding.ts new file mode 100644 index 00000000000..1fc20fdd0ae --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleBinding.ts @@ -0,0 +1,65 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ClusterRoleBinding references a ClusterRole, but not contain it. It can reference any ClusterRole in the same namespace or in the global namespace. It adds who information via (Users and Groups) OR Subjects and namespace information by which namespace it exists in. ClusterRoleBindings in a given namespace only have effect in that namespace (excepting the master namespace which has power in all namespaces). + * @export + * @interface OSV1ClusterRoleBinding + */ +export interface OSV1ClusterRoleBinding { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ClusterRoleBinding + */ + apiVersion?: string; + /** + * GroupNames holds all the groups directly bound to the role. This field should only be specified when supporting legacy clients and servers. See Subjects for further details. + * @type {Array} + * @memberof OSV1ClusterRoleBinding + */ + groupNames: string[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ClusterRoleBinding + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1ClusterRoleBinding + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1ClusterRoleBinding + */ + roleRef: V1ObjectReference; + /** + * Subjects hold object references to authorize with this rule. This field is ignored if UserNames or GroupNames are specified to support legacy clients and servers. Thus newer clients that do not need to support backwards compatibility should send only fully qualified Subjects and should omit the UserNames and GroupNames fields. Clients that need to support backwards compatibility can use this field to build the UserNames and GroupNames. + * @type {Array} + * @memberof OSV1ClusterRoleBinding + */ + subjects: V1ObjectReference[]; + /** + * UserNames holds all the usernames directly bound to the role. This field should only be specified when supporting legacy clients and servers. See Subjects for further details. + * @type {Array} + * @memberof OSV1ClusterRoleBinding + */ + userNames: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleBindingList.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleBindingList.ts new file mode 100644 index 00000000000..0e13da71e1e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleBindingList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ClusterRoleBinding } from './OSV1ClusterRoleBinding'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ClusterRoleBindingList is a collection of ClusterRoleBindings + * @export + * @interface OSV1ClusterRoleBindingList + */ +export interface OSV1ClusterRoleBindingList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ClusterRoleBindingList + */ + apiVersion?: string; + /** + * Items is a list of ClusterRoleBindings + * @type {Array} + * @memberof OSV1ClusterRoleBindingList + */ + items: OSV1ClusterRoleBinding[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ClusterRoleBindingList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1ClusterRoleBindingList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleList.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleList.ts new file mode 100644 index 00000000000..cf931942735 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ClusterRole } from './OSV1ClusterRole'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ClusterRoleList is a collection of ClusterRoles + * @export + * @interface OSV1ClusterRoleList + */ +export interface OSV1ClusterRoleList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ClusterRoleList + */ + apiVersion?: string; + /** + * Items is a list of ClusterRoles + * @type {Array} + * @memberof OSV1ClusterRoleList + */ + items: OSV1ClusterRole[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ClusterRoleList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1ClusterRoleList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleScopeRestriction.ts b/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleScopeRestriction.ts new file mode 100644 index 00000000000..7b3451df4db --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ClusterRoleScopeRestriction.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ClusterRoleScopeRestriction describes restrictions on cluster role scopes + * @export + * @interface OSV1ClusterRoleScopeRestriction + */ +export interface OSV1ClusterRoleScopeRestriction { + /** + * AllowEscalation indicates whether you can request roles and their escalating resources + * @type {boolean} + * @memberof OSV1ClusterRoleScopeRestriction + */ + allowEscalation: boolean; + /** + * Namespaces is the list of namespaces that can be referenced. * means any of them (including *) + * @type {Array} + * @memberof OSV1ClusterRoleScopeRestriction + */ + namespaces: string[]; + /** + * RoleNames is the list of cluster roles that can referenced. * means anything + * @type {Array} + * @memberof OSV1ClusterRoleScopeRestriction + */ + roleNames: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ConfigMapBuildSource.ts b/frontend/packages/kube-types/src/openshift/OSV1ConfigMapBuildSource.ts new file mode 100644 index 00000000000..8103c4d5528 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ConfigMapBuildSource.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * ConfigMapBuildSource describes a configmap and its destination directory that will be used only at the build time. The content of the configmap referenced here will be copied into the destination directory instead of mounting. + * @export + * @interface OSV1ConfigMapBuildSource + */ +export interface OSV1ConfigMapBuildSource { + /** + * + * @type {V1LocalObjectReference} + * @memberof OSV1ConfigMapBuildSource + */ + configMap: V1LocalObjectReference; + /** + * destinationDir is the directory where the files from the configmap should be available for the build time. For the Source build strategy, these will be injected into a container where the assemble script runs. For the container image build strategy, these will be copied into the build directory, where the Dockerfile is located, so users can ADD or COPY them during container image build. + * @type {string} + * @memberof OSV1ConfigMapBuildSource + */ + destinationDir?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1CustomBuildStrategy.ts b/frontend/packages/kube-types/src/openshift/OSV1CustomBuildStrategy.ts new file mode 100644 index 00000000000..ba7b80afc81 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1CustomBuildStrategy.ts @@ -0,0 +1,67 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1SecretSpec } from './OSV1SecretSpec'; +import { V1EnvVar } from './V1EnvVar'; +import { V1LocalObjectReference } from './V1LocalObjectReference'; +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * CustomBuildStrategy defines input parameters specific to Custom build. + * @export + * @interface OSV1CustomBuildStrategy + */ +export interface OSV1CustomBuildStrategy { + /** + * buildAPIVersion is the requested API version for the Build object serialized and passed to the custom builder + * @type {string} + * @memberof OSV1CustomBuildStrategy + */ + buildAPIVersion?: string; + /** + * env contains additional environment variables you want to pass into a builder container. + * @type {Array} + * @memberof OSV1CustomBuildStrategy + */ + env?: V1EnvVar[]; + /** + * exposeDockerSocket will allow running Docker commands (and build container images) from inside the container. + * @type {boolean} + * @memberof OSV1CustomBuildStrategy + */ + exposeDockerSocket?: boolean; + /** + * forcePull describes if the controller should configure the build pod to always pull the images for the builder or only pull if it is not present locally + * @type {boolean} + * @memberof OSV1CustomBuildStrategy + */ + forcePull?: boolean; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1CustomBuildStrategy + */ + from: V1ObjectReference; + /** + * + * @type {V1LocalObjectReference} + * @memberof OSV1CustomBuildStrategy + */ + pullSecret?: V1LocalObjectReference; + /** + * secrets is a list of additional secrets that will be included in the build pod + * @type {Array} + * @memberof OSV1CustomBuildStrategy + */ + secrets?: OSV1SecretSpec[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1CustomDeploymentStrategyParams.ts b/frontend/packages/kube-types/src/openshift/OSV1CustomDeploymentStrategyParams.ts new file mode 100644 index 00000000000..2740746f240 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1CustomDeploymentStrategyParams.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1EnvVar } from './V1EnvVar'; + +/** + * CustomDeploymentStrategyParams are the input to the Custom deployment strategy. + * @export + * @interface OSV1CustomDeploymentStrategyParams + */ +export interface OSV1CustomDeploymentStrategyParams { + /** + * Command is optional and overrides CMD in the container Image. + * @type {Array} + * @memberof OSV1CustomDeploymentStrategyParams + */ + command?: string[]; + /** + * Environment holds the environment which will be given to the container for Image. + * @type {Array} + * @memberof OSV1CustomDeploymentStrategyParams + */ + environment?: V1EnvVar[]; + /** + * Image specifies a container image which can carry out a deployment. + * @type {string} + * @memberof OSV1CustomDeploymentStrategyParams + */ + image?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentCause.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentCause.ts new file mode 100644 index 00000000000..54df91369a3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentCause.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1DeploymentCauseImageTrigger } from './OSV1DeploymentCauseImageTrigger'; + +/** + * DeploymentCause captures information about a particular cause of a deployment. + * @export + * @interface OSV1DeploymentCause + */ +export interface OSV1DeploymentCause { + /** + * + * @type {OSV1DeploymentCauseImageTrigger} + * @memberof OSV1DeploymentCause + */ + imageTrigger?: OSV1DeploymentCauseImageTrigger; + /** + * Type of the trigger that resulted in the creation of a new deployment + * @type {string} + * @memberof OSV1DeploymentCause + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentCauseImageTrigger.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentCauseImageTrigger.ts new file mode 100644 index 00000000000..b9f94f9afd8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentCauseImageTrigger.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * DeploymentCauseImageTrigger represents details about the cause of a deployment originating from an image change trigger + * @export + * @interface OSV1DeploymentCauseImageTrigger + */ +export interface OSV1DeploymentCauseImageTrigger { + /** + * + * @type {V1ObjectReference} + * @memberof OSV1DeploymentCauseImageTrigger + */ + from: V1ObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentCondition.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentCondition.ts new file mode 100644 index 00000000000..434533a6554 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentCondition.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DeploymentCondition describes the state of a deployment config at a certain point. + * @export + * @interface OSV1DeploymentCondition + */ +export interface OSV1DeploymentCondition { + /** + * + * @type {string} + * @memberof OSV1DeploymentCondition + */ + lastTransitionTime?: string; + /** + * + * @type {string} + * @memberof OSV1DeploymentCondition + */ + lastUpdateTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof OSV1DeploymentCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof OSV1DeploymentCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof OSV1DeploymentCondition + */ + status: string; + /** + * Type of deployment condition. + * @type {string} + * @memberof OSV1DeploymentCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfig.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfig.ts new file mode 100644 index 00000000000..fdc258a0f3e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfig.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1DeploymentConfigSpec } from './OSV1DeploymentConfigSpec'; +import { OSV1DeploymentConfigStatus } from './OSV1DeploymentConfigStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Deployment Configs define the template for a pod and manages deploying new images or configuration changes. A single deployment configuration is usually analogous to a single micro-service. Can support many different deployment patterns, including full restart, customizable rolling updates, and fully custom behaviors, as well as pre- and post- deployment hooks. Each individual deployment is represented as a replication controller. A deployment is \"triggered\" when its configuration is changed or a tag in an Image Stream is changed. Triggers can be disabled to allow manual control over a deployment. The \"strategy\" determines how the deployment is carried out and may be changed at any time. The `latestVersion` field is updated when a new deployment is triggered by any means. + * @export + * @interface OSV1DeploymentConfig + */ +export interface OSV1DeploymentConfig { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1DeploymentConfig + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1DeploymentConfig + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1DeploymentConfig + */ + metadata?: V1ObjectMeta; + /** + * + * @type {OSV1DeploymentConfigSpec} + * @memberof OSV1DeploymentConfig + */ + spec: OSV1DeploymentConfigSpec; + /** + * + * @type {OSV1DeploymentConfigStatus} + * @memberof OSV1DeploymentConfig + */ + status?: OSV1DeploymentConfigStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigList.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigList.ts new file mode 100644 index 00000000000..c5d77e1fd7a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1DeploymentConfig } from './OSV1DeploymentConfig'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * DeploymentConfigList is a collection of deployment configs. + * @export + * @interface OSV1DeploymentConfigList + */ +export interface OSV1DeploymentConfigList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1DeploymentConfigList + */ + apiVersion?: string; + /** + * Items is a list of deployment configs + * @type {Array} + * @memberof OSV1DeploymentConfigList + */ + items: OSV1DeploymentConfig[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1DeploymentConfigList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1DeploymentConfigList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigRollback.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigRollback.ts new file mode 100644 index 00000000000..23375e81207 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigRollback.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1DeploymentConfigRollbackSpec } from './OSV1DeploymentConfigRollbackSpec'; + +/** + * DeploymentConfigRollback provides the input to rollback generation. + * @export + * @interface OSV1DeploymentConfigRollback + */ +export interface OSV1DeploymentConfigRollback { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1DeploymentConfigRollback + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1DeploymentConfigRollback + */ + kind?: string; + /** + * Name of the deployment config that will be rolled back. + * @type {string} + * @memberof OSV1DeploymentConfigRollback + */ + name: string; + /** + * + * @type {OSV1DeploymentConfigRollbackSpec} + * @memberof OSV1DeploymentConfigRollback + */ + spec: OSV1DeploymentConfigRollbackSpec; + /** + * UpdatedAnnotations is a set of new annotations that will be added in the deployment config. + * @type {{ [key: string]: string; }} + * @memberof OSV1DeploymentConfigRollback + */ + updatedAnnotations?: { [key: string]: string }; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigRollbackSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigRollbackSpec.ts new file mode 100644 index 00000000000..9bc11f63ee5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigRollbackSpec.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * DeploymentConfigRollbackSpec represents the options for rollback generation. + * @export + * @interface OSV1DeploymentConfigRollbackSpec + */ +export interface OSV1DeploymentConfigRollbackSpec { + /** + * + * @type {V1ObjectReference} + * @memberof OSV1DeploymentConfigRollbackSpec + */ + from: V1ObjectReference; + /** + * IncludeReplicationMeta specifies whether to include the replica count and selector. + * @type {boolean} + * @memberof OSV1DeploymentConfigRollbackSpec + */ + includeReplicationMeta: boolean; + /** + * IncludeStrategy specifies whether to include the deployment Strategy. + * @type {boolean} + * @memberof OSV1DeploymentConfigRollbackSpec + */ + includeStrategy: boolean; + /** + * IncludeTemplate specifies whether to include the PodTemplateSpec. + * @type {boolean} + * @memberof OSV1DeploymentConfigRollbackSpec + */ + includeTemplate: boolean; + /** + * IncludeTriggers specifies whether to include config Triggers. + * @type {boolean} + * @memberof OSV1DeploymentConfigRollbackSpec + */ + includeTriggers: boolean; + /** + * Revision to rollback to. If set to 0, rollback to the last revision. + * @type {number} + * @memberof OSV1DeploymentConfigRollbackSpec + */ + revision?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigSpec.ts new file mode 100644 index 00000000000..b2eb63a3de2 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigSpec.ts @@ -0,0 +1,78 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1DeploymentStrategy } from './OSV1DeploymentStrategy'; +import { OSV1DeploymentTriggerPolicy } from './OSV1DeploymentTriggerPolicy'; +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; + +/** + * DeploymentConfigSpec represents the desired state of the deployment. + * @export + * @interface OSV1DeploymentConfigSpec + */ +export interface OSV1DeploymentConfigSpec { + /** + * MinReadySeconds is the minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) + * @type {number} + * @memberof OSV1DeploymentConfigSpec + */ + minReadySeconds?: number; + /** + * Paused indicates that the deployment config is paused resulting in no new deployments on template changes or changes in the template caused by other triggers. + * @type {boolean} + * @memberof OSV1DeploymentConfigSpec + */ + paused?: boolean; + /** + * Replicas is the number of desired replicas. + * @type {number} + * @memberof OSV1DeploymentConfigSpec + */ + replicas?: number; + /** + * RevisionHistoryLimit is the number of old ReplicationControllers to retain to allow for rollbacks. This field is a pointer to allow for differentiation between an explicit zero and not specified. Defaults to 10. (This only applies to DeploymentConfigs created via the new group API resource, not the legacy resource.) + * @type {number} + * @memberof OSV1DeploymentConfigSpec + */ + revisionHistoryLimit?: number; + /** + * Selector is a label query over pods that should match the Replicas count. + * @type {{ [key: string]: string; }} + * @memberof OSV1DeploymentConfigSpec + */ + selector?: { [key: string]: string }; + /** + * + * @type {OSV1DeploymentStrategy} + * @memberof OSV1DeploymentConfigSpec + */ + strategy?: OSV1DeploymentStrategy; + /** + * + * @type {V1PodTemplateSpec} + * @memberof OSV1DeploymentConfigSpec + */ + template?: V1PodTemplateSpec; + /** + * Test ensures that this deployment config will have zero replicas except while a deployment is running. This allows the deployment config to be used as a continuous deployment test - triggering on images, running the deployment, and then succeeding or failing. Post strategy hooks and After actions can be used to integrate successful deployment with an action. + * @type {boolean} + * @memberof OSV1DeploymentConfigSpec + */ + test?: boolean; + /** + * Triggers determine how updates to a DeploymentConfig result in new deployments. If no triggers are defined, a new deployment can only occur as a result of an explicit client update to the DeploymentConfig with a new LatestVersion. If null, defaults to having a config change trigger. + * @type {Array} + * @memberof OSV1DeploymentConfigSpec + */ + triggers?: OSV1DeploymentTriggerPolicy[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigStatus.ts new file mode 100644 index 00000000000..367c1ce98ed --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentConfigStatus.ts @@ -0,0 +1,77 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1DeploymentCondition } from './OSV1DeploymentCondition'; +import { OSV1DeploymentDetails } from './OSV1DeploymentDetails'; + +/** + * DeploymentConfigStatus represents the current deployment state. + * @export + * @interface OSV1DeploymentConfigStatus + */ +export interface OSV1DeploymentConfigStatus { + /** + * AvailableReplicas is the total number of available pods targeted by this deployment config. + * @type {number} + * @memberof OSV1DeploymentConfigStatus + */ + availableReplicas: number; + /** + * Conditions represents the latest available observations of a deployment config\'s current state. + * @type {Array} + * @memberof OSV1DeploymentConfigStatus + */ + conditions?: OSV1DeploymentCondition[]; + /** + * + * @type {OSV1DeploymentDetails} + * @memberof OSV1DeploymentConfigStatus + */ + details?: OSV1DeploymentDetails; + /** + * LatestVersion is used to determine whether the current deployment associated with a deployment config is out of sync. + * @type {number} + * @memberof OSV1DeploymentConfigStatus + */ + latestVersion: number; + /** + * ObservedGeneration is the most recent generation observed by the deployment config controller. + * @type {number} + * @memberof OSV1DeploymentConfigStatus + */ + observedGeneration: number; + /** + * Total number of ready pods targeted by this deployment. + * @type {number} + * @memberof OSV1DeploymentConfigStatus + */ + readyReplicas?: number; + /** + * Replicas is the total number of pods targeted by this deployment config. + * @type {number} + * @memberof OSV1DeploymentConfigStatus + */ + replicas: number; + /** + * UnavailableReplicas is the total number of unavailable pods targeted by this deployment config. + * @type {number} + * @memberof OSV1DeploymentConfigStatus + */ + unavailableReplicas: number; + /** + * UpdatedReplicas is the total number of non-terminated pods targeted by this deployment config that have the desired template spec. + * @type {number} + * @memberof OSV1DeploymentConfigStatus + */ + updatedReplicas: number; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentDetails.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentDetails.ts new file mode 100644 index 00000000000..e921ef402d8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentDetails.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1DeploymentCause } from './OSV1DeploymentCause'; + +/** + * DeploymentDetails captures information about the causes of a deployment. + * @export + * @interface OSV1DeploymentDetails + */ +export interface OSV1DeploymentDetails { + /** + * Causes are extended data associated with all the causes for creating a new deployment + * @type {Array} + * @memberof OSV1DeploymentDetails + */ + causes: OSV1DeploymentCause[]; + /** + * Message is the user specified change message, if this deployment was triggered manually by the user + * @type {string} + * @memberof OSV1DeploymentDetails + */ + message?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentLog.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentLog.ts new file mode 100644 index 00000000000..89365f497bf --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentLog.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DeploymentLog represents the logs for a deployment + * @export + * @interface OSV1DeploymentLog + */ +export interface OSV1DeploymentLog { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1DeploymentLog + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1DeploymentLog + */ + kind?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentRequest.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentRequest.ts new file mode 100644 index 00000000000..22691129e9a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentRequest.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DeploymentRequest is a request to a deployment config for a new deployment. + * @export + * @interface OSV1DeploymentRequest + */ +export interface OSV1DeploymentRequest { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1DeploymentRequest + */ + apiVersion?: string; + /** + * ExcludeTriggers instructs the instantiator to avoid processing the specified triggers. This field overrides the triggers from latest and allows clients to control specific logic. This field is ignored if not specified. + * @type {Array} + * @memberof OSV1DeploymentRequest + */ + excludeTriggers?: string[]; + /** + * Force will try to force a new deployment to run. If the deployment config is paused, then setting this to true will return an Invalid error. + * @type {boolean} + * @memberof OSV1DeploymentRequest + */ + force: boolean; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1DeploymentRequest + */ + kind?: string; + /** + * Latest will update the deployment config with the latest state from all triggers. + * @type {boolean} + * @memberof OSV1DeploymentRequest + */ + latest: boolean; + /** + * Name of the deployment config for requesting a new deployment. + * @type {string} + * @memberof OSV1DeploymentRequest + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentStrategy.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentStrategy.ts new file mode 100644 index 00000000000..a2d8b7d9f35 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentStrategy.ts @@ -0,0 +1,73 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1CustomDeploymentStrategyParams } from './OSV1CustomDeploymentStrategyParams'; +import { OSV1RecreateDeploymentStrategyParams } from './OSV1RecreateDeploymentStrategyParams'; +import { OSV1RollingDeploymentStrategyParams } from './OSV1RollingDeploymentStrategyParams'; +import { V1ResourceRequirements } from './V1ResourceRequirements'; + +/** + * DeploymentStrategy describes how to perform a deployment. + * @export + * @interface OSV1DeploymentStrategy + */ +export interface OSV1DeploymentStrategy { + /** + * ActiveDeadlineSeconds is the duration in seconds that the deployer pods for this deployment config may be active on a node before the system actively tries to terminate them. + * @type {number} + * @memberof OSV1DeploymentStrategy + */ + activeDeadlineSeconds?: number; + /** + * Annotations is a set of key, value pairs added to custom deployer and lifecycle pre/post hook pods. + * @type {{ [key: string]: string; }} + * @memberof OSV1DeploymentStrategy + */ + annotations?: { [key: string]: string }; + /** + * + * @type {OSV1CustomDeploymentStrategyParams} + * @memberof OSV1DeploymentStrategy + */ + customParams?: OSV1CustomDeploymentStrategyParams; + /** + * Labels is a set of key, value pairs added to custom deployer and lifecycle pre/post hook pods. + * @type {{ [key: string]: string; }} + * @memberof OSV1DeploymentStrategy + */ + labels?: { [key: string]: string }; + /** + * + * @type {OSV1RecreateDeploymentStrategyParams} + * @memberof OSV1DeploymentStrategy + */ + recreateParams?: OSV1RecreateDeploymentStrategyParams; + /** + * + * @type {V1ResourceRequirements} + * @memberof OSV1DeploymentStrategy + */ + resources?: V1ResourceRequirements; + /** + * + * @type {OSV1RollingDeploymentStrategyParams} + * @memberof OSV1DeploymentStrategy + */ + rollingParams?: OSV1RollingDeploymentStrategyParams; + /** + * Type is the name of a deployment strategy. + * @type {string} + * @memberof OSV1DeploymentStrategy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentTriggerImageChangeParams.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentTriggerImageChangeParams.ts new file mode 100644 index 00000000000..738920fb18e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentTriggerImageChangeParams.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * DeploymentTriggerImageChangeParams represents the parameters to the ImageChange trigger. + * @export + * @interface OSV1DeploymentTriggerImageChangeParams + */ +export interface OSV1DeploymentTriggerImageChangeParams { + /** + * Automatic means that the detection of a new tag value should result in an image update inside the pod template. + * @type {boolean} + * @memberof OSV1DeploymentTriggerImageChangeParams + */ + automatic?: boolean; + /** + * ContainerNames is used to restrict tag updates to the specified set of container names in a pod. If multiple triggers point to the same containers, the resulting behavior is undefined. Future API versions will make this a validation error. If ContainerNames does not point to a valid container, the trigger will be ignored. Future API versions will make this a validation error. + * @type {Array} + * @memberof OSV1DeploymentTriggerImageChangeParams + */ + containerNames?: string[]; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1DeploymentTriggerImageChangeParams + */ + from: V1ObjectReference; + /** + * LastTriggeredImage is the last image to be triggered. + * @type {string} + * @memberof OSV1DeploymentTriggerImageChangeParams + */ + lastTriggeredImage?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DeploymentTriggerPolicy.ts b/frontend/packages/kube-types/src/openshift/OSV1DeploymentTriggerPolicy.ts new file mode 100644 index 00000000000..cf74b798946 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DeploymentTriggerPolicy.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1DeploymentTriggerImageChangeParams } from './OSV1DeploymentTriggerImageChangeParams'; + +/** + * DeploymentTriggerPolicy describes a policy for a single trigger that results in a new deployment. + * @export + * @interface OSV1DeploymentTriggerPolicy + */ +export interface OSV1DeploymentTriggerPolicy { + /** + * + * @type {OSV1DeploymentTriggerImageChangeParams} + * @memberof OSV1DeploymentTriggerPolicy + */ + imageChangeParams?: OSV1DeploymentTriggerImageChangeParams; + /** + * Type of the trigger + * @type {string} + * @memberof OSV1DeploymentTriggerPolicy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DockerBuildStrategy.ts b/frontend/packages/kube-types/src/openshift/OSV1DockerBuildStrategy.ts new file mode 100644 index 00000000000..cf3e0ab5d7c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DockerBuildStrategy.ts @@ -0,0 +1,72 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1EnvVar } from './V1EnvVar'; +import { V1LocalObjectReference } from './V1LocalObjectReference'; +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * DockerBuildStrategy defines input parameters specific to container image build. + * @export + * @interface OSV1DockerBuildStrategy + */ +export interface OSV1DockerBuildStrategy { + /** + * buildArgs contains build arguments that will be resolved in the Dockerfile. See https://docs.docker.com/engine/reference/builder/#/arg for more details. + * @type {Array} + * @memberof OSV1DockerBuildStrategy + */ + buildArgs?: V1EnvVar[]; + /** + * dockerfilePath is the path of the Dockerfile that will be used to build the container image, relative to the root of the context (contextDir). + * @type {string} + * @memberof OSV1DockerBuildStrategy + */ + dockerfilePath?: string; + /** + * env contains additional environment variables you want to pass into a builder container. + * @type {Array} + * @memberof OSV1DockerBuildStrategy + */ + env?: V1EnvVar[]; + /** + * forcePull describes if the builder should pull the images from registry prior to building. + * @type {boolean} + * @memberof OSV1DockerBuildStrategy + */ + forcePull?: boolean; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1DockerBuildStrategy + */ + from?: V1ObjectReference; + /** + * imageOptimizationPolicy describes what optimizations the system can use when building images to reduce the final size or time spent building the image. The default policy is \'None\' which means the final build image will be equivalent to an image created by the container image build API. The experimental policy \'SkipLayers\' will avoid commiting new layers in between each image step, and will fail if the Dockerfile cannot provide compatibility with the \'None\' policy. An additional experimental policy \'SkipLayersAndWarn\' is the same as \'SkipLayers\' but simply warns if compatibility cannot be preserved. + * @type {string} + * @memberof OSV1DockerBuildStrategy + */ + imageOptimizationPolicy?: string; + /** + * noCache if set to true indicates that the container image build must be executed with the --no-cache=true flag + * @type {boolean} + * @memberof OSV1DockerBuildStrategy + */ + noCache?: boolean; + /** + * + * @type {V1LocalObjectReference} + * @memberof OSV1DockerBuildStrategy + */ + pullSecret?: V1LocalObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1DockerStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/OSV1DockerStrategyOptions.ts new file mode 100644 index 00000000000..14d758f9074 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1DockerStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1EnvVar } from './V1EnvVar'; + +/** + * DockerStrategyOptions contains extra strategy options for container image builds + * @export + * @interface OSV1DockerStrategyOptions + */ +export interface OSV1DockerStrategyOptions { + /** + * Args contains any build arguments that are to be passed to Docker. See https://docs.docker.com/engine/reference/builder/#/arg for more details + * @type {Array} + * @memberof OSV1DockerStrategyOptions + */ + buildArgs?: V1EnvVar[]; + /** + * noCache overrides the docker-strategy noCache option in the build config + * @type {boolean} + * @memberof OSV1DockerStrategyOptions + */ + noCache?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicy.ts b/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicy.ts new file mode 100644 index 00000000000..8ec7d01c81a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicy.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1EgressNetworkPolicySpec } from './OSV1EgressNetworkPolicySpec'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * EgressNetworkPolicy describes the current egress network policy for a Namespace. When using the \'redhat/openshift-ovs-multitenant\' network plugin, traffic from a pod to an IP address outside the cluster will be checked against each EgressNetworkPolicyRule in the pod\'s namespace\'s EgressNetworkPolicy, in order. If no rule matches (or no EgressNetworkPolicy is present) then the traffic will be allowed by default. + * @export + * @interface OSV1EgressNetworkPolicy + */ +export interface OSV1EgressNetworkPolicy { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1EgressNetworkPolicy + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1EgressNetworkPolicy + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1EgressNetworkPolicy + */ + metadata?: V1ObjectMeta; + /** + * + * @type {OSV1EgressNetworkPolicySpec} + * @memberof OSV1EgressNetworkPolicy + */ + spec: OSV1EgressNetworkPolicySpec; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyList.ts b/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyList.ts new file mode 100644 index 00000000000..96149cef60d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1EgressNetworkPolicy } from './OSV1EgressNetworkPolicy'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * EgressNetworkPolicyList is a collection of EgressNetworkPolicy + * @export + * @interface OSV1EgressNetworkPolicyList + */ +export interface OSV1EgressNetworkPolicyList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1EgressNetworkPolicyList + */ + apiVersion?: string; + /** + * items is the list of policies + * @type {Array} + * @memberof OSV1EgressNetworkPolicyList + */ + items: OSV1EgressNetworkPolicy[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1EgressNetworkPolicyList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1EgressNetworkPolicyList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyPeer.ts b/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyPeer.ts new file mode 100644 index 00000000000..aedcc7e2c54 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyPeer.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * EgressNetworkPolicyPeer specifies a target to apply egress network policy to + * @export + * @interface OSV1EgressNetworkPolicyPeer + */ +export interface OSV1EgressNetworkPolicyPeer { + /** + * cidrSelector is the CIDR range to allow/deny traffic to. If this is set, dnsName must be unset + * @type {string} + * @memberof OSV1EgressNetworkPolicyPeer + */ + cidrSelector?: string; + /** + * dnsName is the domain name to allow/deny traffic to. If this is set, cidrSelector must be unset + * @type {string} + * @memberof OSV1EgressNetworkPolicyPeer + */ + dnsName?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyRule.ts b/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyRule.ts new file mode 100644 index 00000000000..105bd7aa729 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicyRule.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1EgressNetworkPolicyPeer } from './OSV1EgressNetworkPolicyPeer'; + +/** + * EgressNetworkPolicyRule contains a single egress network policy rule + * @export + * @interface OSV1EgressNetworkPolicyRule + */ +export interface OSV1EgressNetworkPolicyRule { + /** + * + * @type {OSV1EgressNetworkPolicyPeer} + * @memberof OSV1EgressNetworkPolicyRule + */ + to: OSV1EgressNetworkPolicyPeer; + /** + * type marks this as an \"Allow\" or \"Deny\" rule + * @type {string} + * @memberof OSV1EgressNetworkPolicyRule + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicySpec.ts b/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicySpec.ts new file mode 100644 index 00000000000..e3bc553aac9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1EgressNetworkPolicySpec.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1EgressNetworkPolicyRule } from './OSV1EgressNetworkPolicyRule'; + +/** + * EgressNetworkPolicySpec provides a list of policies on outgoing network traffic + * @export + * @interface OSV1EgressNetworkPolicySpec + */ +export interface OSV1EgressNetworkPolicySpec { + /** + * egress contains the list of egress policy rules + * @type {Array} + * @memberof OSV1EgressNetworkPolicySpec + */ + egress: OSV1EgressNetworkPolicyRule[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ExecNewPodHook.ts b/frontend/packages/kube-types/src/openshift/OSV1ExecNewPodHook.ts new file mode 100644 index 00000000000..5822274a081 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ExecNewPodHook.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1EnvVar } from './V1EnvVar'; + +/** + * ExecNewPodHook is a hook implementation which runs a command in a new pod based on the specified container which is assumed to be part of the deployment template. + * @export + * @interface OSV1ExecNewPodHook + */ +export interface OSV1ExecNewPodHook { + /** + * Command is the action command and its arguments. + * @type {Array} + * @memberof OSV1ExecNewPodHook + */ + command: string[]; + /** + * ContainerName is the name of a container in the deployment pod template whose container image will be used for the hook pod\'s container. + * @type {string} + * @memberof OSV1ExecNewPodHook + */ + containerName: string; + /** + * Env is a set of environment variables to supply to the hook pod\'s container. + * @type {Array} + * @memberof OSV1ExecNewPodHook + */ + env?: V1EnvVar[]; + /** + * Volumes is a list of named volumes from the pod template which should be copied to the hook pod. Volumes names not found in pod spec are ignored. An empty list means no volumes will be copied. + * @type {Array} + * @memberof OSV1ExecNewPodHook + */ + volumes?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1FSGroupStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/OSV1FSGroupStrategyOptions.ts new file mode 100644 index 00000000000..e337cccf234 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1FSGroupStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1IDRange } from './OSV1IDRange'; + +/** + * FSGroupStrategyOptions defines the strategy type and options used to create the strategy. + * @export + * @interface OSV1FSGroupStrategyOptions + */ +export interface OSV1FSGroupStrategyOptions { + /** + * Ranges are the allowed ranges of fs groups. If you would like to force a single fs group then supply a single range with the same start and end. + * @type {Array} + * @memberof OSV1FSGroupStrategyOptions + */ + ranges?: OSV1IDRange[]; + /** + * Type is the strategy that will dictate what FSGroup is used in the SecurityContext. + * @type {string} + * @memberof OSV1FSGroupStrategyOptions + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1GenericWebHookCause.ts b/frontend/packages/kube-types/src/openshift/OSV1GenericWebHookCause.ts new file mode 100644 index 00000000000..309154764eb --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1GenericWebHookCause.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1SourceRevision } from './OSV1SourceRevision'; + +/** + * GenericWebHookCause holds information about a generic WebHook that triggered a build. + * @export + * @interface OSV1GenericWebHookCause + */ +export interface OSV1GenericWebHookCause { + /** + * + * @type {OSV1SourceRevision} + * @memberof OSV1GenericWebHookCause + */ + revision?: OSV1SourceRevision; + /** + * secret is the obfuscated webhook secret that triggered a build. + * @type {string} + * @memberof OSV1GenericWebHookCause + */ + secret?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1GitBuildSource.ts b/frontend/packages/kube-types/src/openshift/OSV1GitBuildSource.ts new file mode 100644 index 00000000000..50c96ffb595 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1GitBuildSource.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * GitBuildSource defines the parameters of a Git SCM + * @export + * @interface OSV1GitBuildSource + */ +export interface OSV1GitBuildSource { + /** + * httpProxy is a proxy used to reach the git repository over http + * @type {string} + * @memberof OSV1GitBuildSource + */ + httpProxy?: string; + /** + * httpsProxy is a proxy used to reach the git repository over https + * @type {string} + * @memberof OSV1GitBuildSource + */ + httpsProxy?: string; + /** + * noProxy is the list of domains for which the proxy should not be used + * @type {string} + * @memberof OSV1GitBuildSource + */ + noProxy?: string; + /** + * ref is the branch/tag/ref to build. + * @type {string} + * @memberof OSV1GitBuildSource + */ + ref?: string; + /** + * uri points to the source that will be built. The structure of the source will depend on the type of build to run + * @type {string} + * @memberof OSV1GitBuildSource + */ + uri: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1GitHubWebHookCause.ts b/frontend/packages/kube-types/src/openshift/OSV1GitHubWebHookCause.ts new file mode 100644 index 00000000000..ba62ba81ee1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1GitHubWebHookCause.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1SourceRevision } from './OSV1SourceRevision'; + +/** + * GitHubWebHookCause has information about a GitHub webhook that triggered a build. + * @export + * @interface OSV1GitHubWebHookCause + */ +export interface OSV1GitHubWebHookCause { + /** + * + * @type {OSV1SourceRevision} + * @memberof OSV1GitHubWebHookCause + */ + revision?: OSV1SourceRevision; + /** + * secret is the obfuscated webhook secret that triggered a build. + * @type {string} + * @memberof OSV1GitHubWebHookCause + */ + secret?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1GitLabWebHookCause.ts b/frontend/packages/kube-types/src/openshift/OSV1GitLabWebHookCause.ts new file mode 100644 index 00000000000..1715b4e9e6f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1GitLabWebHookCause.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1SourceRevision } from './OSV1SourceRevision'; + +/** + * GitLabWebHookCause has information about a GitLab webhook that triggered a build. + * @export + * @interface OSV1GitLabWebHookCause + */ +export interface OSV1GitLabWebHookCause { + /** + * + * @type {OSV1SourceRevision} + * @memberof OSV1GitLabWebHookCause + */ + revision?: OSV1SourceRevision; + /** + * Secret is the obfuscated webhook secret that triggered a build. + * @type {string} + * @memberof OSV1GitLabWebHookCause + */ + secret?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1GitSourceRevision.ts b/frontend/packages/kube-types/src/openshift/OSV1GitSourceRevision.ts new file mode 100644 index 00000000000..e37a81129b0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1GitSourceRevision.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1SourceControlUser } from './OSV1SourceControlUser'; + +/** + * GitSourceRevision is the commit information from a git source for a build + * @export + * @interface OSV1GitSourceRevision + */ +export interface OSV1GitSourceRevision { + /** + * + * @type {OSV1SourceControlUser} + * @memberof OSV1GitSourceRevision + */ + author?: OSV1SourceControlUser; + /** + * commit is the commit hash identifying a specific commit + * @type {string} + * @memberof OSV1GitSourceRevision + */ + commit?: string; + /** + * + * @type {OSV1SourceControlUser} + * @memberof OSV1GitSourceRevision + */ + committer?: OSV1SourceControlUser; + /** + * message is the description of a specific commit + * @type {string} + * @memberof OSV1GitSourceRevision + */ + message?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1Group.ts b/frontend/packages/kube-types/src/openshift/OSV1Group.ts new file mode 100644 index 00000000000..f9e28622aed --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1Group.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Group represents a referenceable set of Users + * @export + * @interface OSV1Group + */ +export interface OSV1Group { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1Group + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1Group + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1Group + */ + metadata?: V1ObjectMeta; + /** + * Users is the list of users in this group. + * @type {Array} + * @memberof OSV1Group + */ + users: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1GroupList.ts b/frontend/packages/kube-types/src/openshift/OSV1GroupList.ts new file mode 100644 index 00000000000..47479dbbdb2 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1GroupList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1Group } from './OSV1Group'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * GroupList is a collection of Groups + * @export + * @interface OSV1GroupList + */ +export interface OSV1GroupList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1GroupList + */ + apiVersion?: string; + /** + * Items is the list of groups + * @type {Array} + * @memberof OSV1GroupList + */ + items: OSV1Group[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1GroupList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1GroupList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1GroupRestriction.ts b/frontend/packages/kube-types/src/openshift/OSV1GroupRestriction.ts new file mode 100644 index 00000000000..56181e62307 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1GroupRestriction.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * GroupRestriction matches a group either by a string match on the group name or a label selector applied to group labels. + * @export + * @interface OSV1GroupRestriction + */ +export interface OSV1GroupRestriction { + /** + * Groups is a list of groups used to match against an individual user\'s groups. If the user is a member of one of the whitelisted groups, the user is allowed to be bound to a role. + * @type {Array} + * @memberof OSV1GroupRestriction + */ + groups: string[]; + /** + * Selectors specifies a list of label selectors over group labels. + * @type {Array} + * @memberof OSV1GroupRestriction + */ + labels: V1LabelSelector[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1HostSubnet.ts b/frontend/packages/kube-types/src/openshift/OSV1HostSubnet.ts new file mode 100644 index 00000000000..90aeede5341 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1HostSubnet.ts @@ -0,0 +1,70 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * HostSubnet describes the container subnet network on a node. The HostSubnet object must have the same name as the Node object it corresponds to. + * @export + * @interface OSV1HostSubnet + */ +export interface OSV1HostSubnet { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1HostSubnet + */ + apiVersion?: string; + /** + * EgressCIDRs is the list of CIDR ranges available for automatically assigning egress IPs to this node from. If this field is set then EgressIPs should be treated as read-only. + * @type {Array} + * @memberof OSV1HostSubnet + */ + egressCIDRs?: string[]; + /** + * EgressIPs is the list of automatic egress IP addresses currently hosted by this node. If EgressCIDRs is empty, this can be set by hand; if EgressCIDRs is set then the master will overwrite the value here with its own allocation of egress IPs. + * @type {Array} + * @memberof OSV1HostSubnet + */ + egressIPs?: string[]; + /** + * Host is the name of the node. (This is the same as the object\'s name, but both fields must be set.) + * @type {string} + * @memberof OSV1HostSubnet + */ + host: string; + /** + * HostIP is the IP address to be used as a VTEP by other nodes in the overlay network + * @type {string} + * @memberof OSV1HostSubnet + */ + hostIP: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1HostSubnet + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1HostSubnet + */ + metadata?: V1ObjectMeta; + /** + * Subnet is the CIDR range of the overlay network assigned to the node for its pods + * @type {string} + * @memberof OSV1HostSubnet + */ + subnet: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1HostSubnetList.ts b/frontend/packages/kube-types/src/openshift/OSV1HostSubnetList.ts new file mode 100644 index 00000000000..9b6dbe2ef46 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1HostSubnetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1HostSubnet } from './OSV1HostSubnet'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * HostSubnetList is a collection of HostSubnets + * @export + * @interface OSV1HostSubnetList + */ +export interface OSV1HostSubnetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1HostSubnetList + */ + apiVersion?: string; + /** + * Items is the list of host subnets + * @type {Array} + * @memberof OSV1HostSubnetList + */ + items: OSV1HostSubnet[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1HostSubnetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1HostSubnetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1IDRange.ts b/frontend/packages/kube-types/src/openshift/OSV1IDRange.ts new file mode 100644 index 00000000000..6f98fe777b9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1IDRange.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * IDRange provides a min/max of an allowed range of IDs. + * @export + * @interface OSV1IDRange + */ +export interface OSV1IDRange { + /** + * Max is the end of the range, inclusive. + * @type {number} + * @memberof OSV1IDRange + */ + max?: number; + /** + * Min is the start of the range, inclusive. + * @type {number} + * @memberof OSV1IDRange + */ + min?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1Identity.ts b/frontend/packages/kube-types/src/openshift/OSV1Identity.ts new file mode 100644 index 00000000000..029062214a6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1Identity.ts @@ -0,0 +1,65 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Identity records a successful authentication of a user with an identity provider. The information about the source of authentication is stored on the identity, and the identity is then associated with a single user object. Multiple identities can reference a single user. Information retrieved from the authentication provider is stored in the extra field using a schema determined by the provider. + * @export + * @interface OSV1Identity + */ +export interface OSV1Identity { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1Identity + */ + apiVersion?: string; + /** + * Extra holds extra information about this identity + * @type {{ [key: string]: string; }} + * @memberof OSV1Identity + */ + extra?: { [key: string]: string }; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1Identity + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1Identity + */ + metadata?: V1ObjectMeta; + /** + * ProviderName is the source of identity information + * @type {string} + * @memberof OSV1Identity + */ + providerName: string; + /** + * ProviderUserName uniquely represents this identity in the scope of the provider + * @type {string} + * @memberof OSV1Identity + */ + providerUserName: string; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1Identity + */ + user: V1ObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1IdentityList.ts b/frontend/packages/kube-types/src/openshift/OSV1IdentityList.ts new file mode 100644 index 00000000000..b46a6729369 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1IdentityList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1Identity } from './OSV1Identity'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * IdentityList is a collection of Identities + * @export + * @interface OSV1IdentityList + */ +export interface OSV1IdentityList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1IdentityList + */ + apiVersion?: string; + /** + * Items is the list of identities + * @type {Array} + * @memberof OSV1IdentityList + */ + items: OSV1Identity[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1IdentityList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1IdentityList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1Image.ts b/frontend/packages/kube-types/src/openshift/OSV1Image.ts new file mode 100644 index 00000000000..88a03c3a303 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1Image.ts @@ -0,0 +1,97 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageLayer } from './OSV1ImageLayer'; +import { OSV1ImageSignature } from './OSV1ImageSignature'; +import { V1ObjectMeta } from './V1ObjectMeta'; +import { IoK8sApimachineryPkgRuntimeRawExtension } from './IoK8sApimachineryPkgRuntimeRawExtension'; + +/** + * Image is an immutable representation of a container image and metadata at a point in time. + * @export + * @interface OSV1Image + */ +export interface OSV1Image { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1Image + */ + apiVersion?: string; + /** + * DockerImageConfig is a JSON blob that the runtime uses to set up the container. This is a part of manifest schema v2. + * @type {string} + * @memberof OSV1Image + */ + dockerImageConfig?: string; + /** + * DockerImageLayers represents the layers in the image. May not be set if the image does not define that data. + * @type {Array} + * @memberof OSV1Image + */ + dockerImageLayers: OSV1ImageLayer[]; + /** + * DockerImageManifest is the raw JSON of the manifest + * @type {string} + * @memberof OSV1Image + */ + dockerImageManifest?: string; + /** + * DockerImageManifestMediaType specifies the mediaType of manifest. This is a part of manifest schema v2. + * @type {string} + * @memberof OSV1Image + */ + dockerImageManifestMediaType?: string; + /** + * + * @type {IoK8sApimachineryPkgRuntimeRawExtension} + * @memberof OSV1Image + */ + dockerImageMetadata?: IoK8sApimachineryPkgRuntimeRawExtension; + /** + * DockerImageMetadataVersion conveys the version of the object, which if empty defaults to \"1.0\" + * @type {string} + * @memberof OSV1Image + */ + dockerImageMetadataVersion?: string; + /** + * DockerImageReference is the string that can be used to pull this image. + * @type {string} + * @memberof OSV1Image + */ + dockerImageReference?: string; + /** + * DockerImageSignatures provides the signatures as opaque blobs. This is a part of manifest schema v1. + * @type {Array} + * @memberof OSV1Image + */ + dockerImageSignatures?: string[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1Image + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1Image + */ + metadata?: V1ObjectMeta; + /** + * Signatures holds all signatures of the image. + * @type {Array} + * @memberof OSV1Image + */ + signatures?: OSV1ImageSignature[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageBlobReferences.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageBlobReferences.ts new file mode 100644 index 00000000000..80f0c5393ed --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageBlobReferences.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ImageBlobReferences describes the blob references within an image. + * @export + * @interface OSV1ImageBlobReferences + */ +export interface OSV1ImageBlobReferences { + /** + * config, if set, is the blob that contains the image config. Some images do not have separate config blobs and this field will be set to nil if so. + * @type {string} + * @memberof OSV1ImageBlobReferences + */ + config?: string; + /** + * imageMissing is true if the image is referenced by the image stream but the image object has been deleted from the API by an administrator. When this field is set, layers and config fields may be empty and callers that depend on the image metadata should consider the image to be unavailable for download or viewing. + * @type {boolean} + * @memberof OSV1ImageBlobReferences + */ + imageMissing?: boolean; + /** + * layers is the list of blobs that compose this image, from base layer to top layer. All layers referenced by this array will be defined in the blobs map. Some images may have zero layers. + * @type {Array} + * @memberof OSV1ImageBlobReferences + */ + layers?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageChangeCause.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageChangeCause.ts new file mode 100644 index 00000000000..8fd22e77f15 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageChangeCause.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * ImageChangeCause contains information about the image that triggered a build + * @export + * @interface OSV1ImageChangeCause + */ +export interface OSV1ImageChangeCause { + /** + * + * @type {V1ObjectReference} + * @memberof OSV1ImageChangeCause + */ + fromRef?: V1ObjectReference; + /** + * imageID is the ID of the image that triggered a a new build. + * @type {string} + * @memberof OSV1ImageChangeCause + */ + imageID?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageChangeTrigger.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageChangeTrigger.ts new file mode 100644 index 00000000000..fb43eb7b66d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageChangeTrigger.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * ImageChangeTrigger allows builds to be triggered when an ImageStream changes + * @export + * @interface OSV1ImageChangeTrigger + */ +export interface OSV1ImageChangeTrigger { + /** + * + * @type {V1ObjectReference} + * @memberof OSV1ImageChangeTrigger + */ + from?: V1ObjectReference; + /** + * lastTriggeredImageID is used internally by the ImageChangeController to save last used image ID for build + * @type {string} + * @memberof OSV1ImageChangeTrigger + */ + lastTriggeredImageID?: string; + /** + * paused is true if this trigger is temporarily disabled. Optional. + * @type {boolean} + * @memberof OSV1ImageChangeTrigger + */ + paused?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageImportSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageImportSpec.ts new file mode 100644 index 00000000000..c56293dd609 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageImportSpec.ts @@ -0,0 +1,55 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1TagImportPolicy } from './OSV1TagImportPolicy'; +import { OSV1TagReferencePolicy } from './OSV1TagReferencePolicy'; +import { V1LocalObjectReference } from './V1LocalObjectReference'; +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * ImageImportSpec describes a request to import a specific image. + * @export + * @interface OSV1ImageImportSpec + */ +export interface OSV1ImageImportSpec { + /** + * + * @type {V1ObjectReference} + * @memberof OSV1ImageImportSpec + */ + from: V1ObjectReference; + /** + * + * @type {OSV1TagImportPolicy} + * @memberof OSV1ImageImportSpec + */ + importPolicy?: OSV1TagImportPolicy; + /** + * IncludeManifest determines if the manifest for each image is returned in the response + * @type {boolean} + * @memberof OSV1ImageImportSpec + */ + includeManifest?: boolean; + /** + * + * @type {OSV1TagReferencePolicy} + * @memberof OSV1ImageImportSpec + */ + referencePolicy?: OSV1TagReferencePolicy; + /** + * + * @type {V1LocalObjectReference} + * @memberof OSV1ImageImportSpec + */ + to?: V1LocalObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageImportStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageImportStatus.ts new file mode 100644 index 00000000000..e1e83bb5c67 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageImportStatus.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1Image } from './OSV1Image'; +import { V1Status } from './V1Status'; + +/** + * ImageImportStatus describes the result of an image import. + * @export + * @interface OSV1ImageImportStatus + */ +export interface OSV1ImageImportStatus { + /** + * + * @type {OSV1Image} + * @memberof OSV1ImageImportStatus + */ + image?: OSV1Image; + /** + * + * @type {V1Status} + * @memberof OSV1ImageImportStatus + */ + status: V1Status; + /** + * Tag is the tag this image was located under, if any + * @type {string} + * @memberof OSV1ImageImportStatus + */ + tag?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageLabel.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageLabel.ts new file mode 100644 index 00000000000..0d35101f2d4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageLabel.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ImageLabel represents a label applied to the resulting image. + * @export + * @interface OSV1ImageLabel + */ +export interface OSV1ImageLabel { + /** + * name defines the name of the label. It must have non-zero length. + * @type {string} + * @memberof OSV1ImageLabel + */ + name: string; + /** + * value defines the literal value of the label. + * @type {string} + * @memberof OSV1ImageLabel + */ + value?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageLayer.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageLayer.ts new file mode 100644 index 00000000000..330a7d637a7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageLayer.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ImageLayer represents a single layer of the image. Some images may have multiple layers. Some may have none. + * @export + * @interface OSV1ImageLayer + */ +export interface OSV1ImageLayer { + /** + * MediaType of the referenced object. + * @type {string} + * @memberof OSV1ImageLayer + */ + mediaType: string; + /** + * Name of the layer as defined by the underlying store. + * @type {string} + * @memberof OSV1ImageLayer + */ + name: string; + /** + * Size of the layer in bytes as defined by the underlying store. + * @type {number} + * @memberof OSV1ImageLayer + */ + size: number; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageLayerData.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageLayerData.ts new file mode 100644 index 00000000000..f2b3e63b824 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageLayerData.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ImageLayerData contains metadata about an image layer. + * @export + * @interface OSV1ImageLayerData + */ +export interface OSV1ImageLayerData { + /** + * MediaType of the referenced object. + * @type {string} + * @memberof OSV1ImageLayerData + */ + mediaType: string; + /** + * Size of the layer in bytes as defined by the underlying store. This field is optional if the necessary information about size is not available. + * @type {number} + * @memberof OSV1ImageLayerData + */ + size: number; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageList.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageList.ts new file mode 100644 index 00000000000..4fa70f02957 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1Image } from './OSV1Image'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ImageList is a list of Image objects. + * @export + * @interface OSV1ImageList + */ +export interface OSV1ImageList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ImageList + */ + apiVersion?: string; + /** + * Items is a list of images + * @type {Array} + * @memberof OSV1ImageList + */ + items: OSV1Image[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ImageList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1ImageList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageLookupPolicy.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageLookupPolicy.ts new file mode 100644 index 00000000000..0d2f441626f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageLookupPolicy.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ImageLookupPolicy describes how an image stream can be used to override the image references used by pods, builds, and other resources in a namespace. + * @export + * @interface OSV1ImageLookupPolicy + */ +export interface OSV1ImageLookupPolicy { + /** + * local will change the docker short image references (like \"mysql\" or \"php:latest\") on objects in this namespace to the image ID whenever they match this image stream, instead of reaching out to a remote registry. The name will be fully qualified to an image ID if found. The tag\'s referencePolicy is taken into account on the replaced value. Only works within the current namespace. + * @type {boolean} + * @memberof OSV1ImageLookupPolicy + */ + local: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageSignature.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageSignature.ts new file mode 100644 index 00000000000..af0fd1af516 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageSignature.ts @@ -0,0 +1,91 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1SignatureCondition } from './OSV1SignatureCondition'; +import { OSV1SignatureIssuer } from './OSV1SignatureIssuer'; +import { OSV1SignatureSubject } from './OSV1SignatureSubject'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ImageSignature holds a signature of an image. It allows to verify image identity and possibly other claims as long as the signature is trusted. Based on this information it is possible to restrict runnable images to those matching cluster-wide policy. Mandatory fields should be parsed by clients doing image verification. The others are parsed from signature\'s content by the server. They serve just an informative purpose. + * @export + * @interface OSV1ImageSignature + */ +export interface OSV1ImageSignature { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ImageSignature + */ + apiVersion?: string; + /** + * Conditions represent the latest available observations of a signature\'s current state. + * @type {Array} + * @memberof OSV1ImageSignature + */ + conditions?: OSV1SignatureCondition[]; + /** + * Required: An opaque binary string which is an image\'s signature. + * @type {string} + * @memberof OSV1ImageSignature + */ + content: string; + /** + * + * @type {string} + * @memberof OSV1ImageSignature + */ + created?: string; + /** + * A human readable string representing image\'s identity. It could be a product name and version, or an image pull spec (e.g. \"registry.access.redhat.com/rhel7/rhel:7.2\"). + * @type {string} + * @memberof OSV1ImageSignature + */ + imageIdentity?: string; + /** + * + * @type {OSV1SignatureIssuer} + * @memberof OSV1ImageSignature + */ + issuedBy?: OSV1SignatureIssuer; + /** + * + * @type {OSV1SignatureSubject} + * @memberof OSV1ImageSignature + */ + issuedTo?: OSV1SignatureSubject; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ImageSignature + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1ImageSignature + */ + metadata?: V1ObjectMeta; + /** + * Contains claims from the signature. + * @type {{ [key: string]: string; }} + * @memberof OSV1ImageSignature + */ + signedClaims?: { [key: string]: string }; + /** + * Required: Describes a type of stored blob. + * @type {string} + * @memberof OSV1ImageSignature + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageSource.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageSource.ts new file mode 100644 index 00000000000..50ede65e5ad --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageSource.ts @@ -0,0 +1,48 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageSourcePath } from './OSV1ImageSourcePath'; +import { V1LocalObjectReference } from './V1LocalObjectReference'; +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * ImageSource is used to describe build source that will be extracted from an image or used during a multi stage build. A reference of type ImageStreamTag, ImageStreamImage or DockerImage may be used. A pull secret can be specified to pull the image from an external registry or override the default service account secret if pulling from the internal registry. Image sources can either be used to extract content from an image and place it into the build context along with the repository source, or used directly during a multi-stage container image build to allow content to be copied without overwriting the contents of the repository source (see the \'paths\' and \'as\' fields). + * @export + * @interface OSV1ImageSource + */ +export interface OSV1ImageSource { + /** + * A list of image names that this source will be used in place of during a multi-stage container image build. For instance, a Dockerfile that uses \"COPY --from=nginx:latest\" will first check for an image source that has \"nginx:latest\" in this field before attempting to pull directly. If the Dockerfile does not reference an image source it is ignored. This field and paths may both be set, in which case the contents will be used twice. + * @type {Array} + * @memberof OSV1ImageSource + */ + as?: string[]; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1ImageSource + */ + from: V1ObjectReference; + /** + * paths is a list of source and destination paths to copy from the image. This content will be copied into the build context prior to starting the build. If no paths are set, the build context will not be altered. + * @type {Array} + * @memberof OSV1ImageSource + */ + paths?: OSV1ImageSourcePath[]; + /** + * + * @type {V1LocalObjectReference} + * @memberof OSV1ImageSource + */ + pullSecret?: V1LocalObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageSourcePath.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageSourcePath.ts new file mode 100644 index 00000000000..6103df01bf7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageSourcePath.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ImageSourcePath describes a path to be copied from a source image and its destination within the build directory. + * @export + * @interface OSV1ImageSourcePath + */ +export interface OSV1ImageSourcePath { + /** + * destinationDir is the relative directory within the build directory where files copied from the image are placed. + * @type {string} + * @memberof OSV1ImageSourcePath + */ + destinationDir: string; + /** + * sourcePath is the absolute path of the file or directory inside the image to copy to the build directory. If the source path ends in /. then the content of the directory will be copied, but the directory itself will not be created at the destination. + * @type {string} + * @memberof OSV1ImageSourcePath + */ + sourcePath: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStream.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStream.ts new file mode 100644 index 00000000000..9d866ce75fe --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStream.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageStreamSpec } from './OSV1ImageStreamSpec'; +import { OSV1ImageStreamStatus } from './OSV1ImageStreamStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ImageStream stores a mapping of tags to images, metadata overrides that are applied when images are tagged in a stream, and an optional reference to a container image repository on a registry. + * @export + * @interface OSV1ImageStream + */ +export interface OSV1ImageStream { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ImageStream + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ImageStream + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1ImageStream + */ + metadata?: V1ObjectMeta; + /** + * + * @type {OSV1ImageStreamSpec} + * @memberof OSV1ImageStream + */ + spec: OSV1ImageStreamSpec; + /** + * + * @type {OSV1ImageStreamStatus} + * @memberof OSV1ImageStream + */ + status?: OSV1ImageStreamStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImage.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImage.ts new file mode 100644 index 00000000000..e3d90130583 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImage.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1Image } from './OSV1Image'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ImageStreamImage represents an Image that is retrieved by image name from an ImageStream. + * @export + * @interface OSV1ImageStreamImage + */ +export interface OSV1ImageStreamImage { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ImageStreamImage + */ + apiVersion?: string; + /** + * + * @type {OSV1Image} + * @memberof OSV1ImageStreamImage + */ + image: OSV1Image; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ImageStreamImage + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1ImageStreamImage + */ + metadata?: V1ObjectMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImport.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImport.ts new file mode 100644 index 00000000000..67252cbbad9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImport.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageStreamImportSpec } from './OSV1ImageStreamImportSpec'; +import { OSV1ImageStreamImportStatus } from './OSV1ImageStreamImportStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * The image stream import resource provides an easy way for a user to find and import container images from other container image registries into the server. Individual images or an entire image repository may be imported, and users may choose to see the results of the import prior to tagging the resulting images into the specified image stream. This API is intended for end-user tools that need to see the metadata of the image prior to import (for instance, to generate an application from it). Clients that know the desired image can continue to create spec.tags directly into their image streams. + * @export + * @interface OSV1ImageStreamImport + */ +export interface OSV1ImageStreamImport { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ImageStreamImport + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ImageStreamImport + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1ImageStreamImport + */ + metadata?: V1ObjectMeta; + /** + * + * @type {OSV1ImageStreamImportSpec} + * @memberof OSV1ImageStreamImport + */ + spec: OSV1ImageStreamImportSpec; + /** + * + * @type {OSV1ImageStreamImportStatus} + * @memberof OSV1ImageStreamImport + */ + status: OSV1ImageStreamImportStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImportSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImportSpec.ts new file mode 100644 index 00000000000..432982408db --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImportSpec.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageImportSpec } from './OSV1ImageImportSpec'; +import { OSV1RepositoryImportSpec } from './OSV1RepositoryImportSpec'; + +/** + * ImageStreamImportSpec defines what images should be imported. + * @export + * @interface OSV1ImageStreamImportSpec + */ +export interface OSV1ImageStreamImportSpec { + /** + * Images are a list of individual images to import. + * @type {Array} + * @memberof OSV1ImageStreamImportSpec + */ + images?: OSV1ImageImportSpec[]; + /** + * Import indicates whether to perform an import - if so, the specified tags are set on the spec and status of the image stream defined by the type meta. + * @type {boolean} + * @memberof OSV1ImageStreamImportSpec + */ + _import: boolean; + /** + * + * @type {OSV1RepositoryImportSpec} + * @memberof OSV1ImageStreamImportSpec + */ + repository?: OSV1RepositoryImportSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImportStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImportStatus.ts new file mode 100644 index 00000000000..f6792d47232 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamImportStatus.ts @@ -0,0 +1,42 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageImportStatus } from './OSV1ImageImportStatus'; +import { OSV1ImageStream } from './OSV1ImageStream'; +import { OSV1RepositoryImportStatus } from './OSV1RepositoryImportStatus'; + +/** + * ImageStreamImportStatus contains information about the status of an image stream import. + * @export + * @interface OSV1ImageStreamImportStatus + */ +export interface OSV1ImageStreamImportStatus { + /** + * Images is set with the result of importing spec.images + * @type {Array} + * @memberof OSV1ImageStreamImportStatus + */ + images?: OSV1ImageImportStatus[]; + /** + * + * @type {OSV1ImageStream} + * @memberof OSV1ImageStreamImportStatus + */ + _import?: OSV1ImageStream; + /** + * + * @type {OSV1RepositoryImportStatus} + * @memberof OSV1ImageStreamImportStatus + */ + repository?: OSV1RepositoryImportStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStreamLayers.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamLayers.ts new file mode 100644 index 00000000000..9d8c51be463 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamLayers.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageBlobReferences } from './OSV1ImageBlobReferences'; +import { OSV1ImageLayerData } from './OSV1ImageLayerData'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ImageStreamLayers describes information about the layers referenced by images in this image stream. + * @export + * @interface OSV1ImageStreamLayers + */ +export interface OSV1ImageStreamLayers { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ImageStreamLayers + */ + apiVersion?: string; + /** + * blobs is a map of blob name to metadata about the blob. + * @type {{ [key: string]: OSV1ImageLayerData; }} + * @memberof OSV1ImageStreamLayers + */ + blobs: { [key: string]: OSV1ImageLayerData }; + /** + * images is a map between an image name and the names of the blobs and config that comprise the image. + * @type {{ [key: string]: OSV1ImageBlobReferences; }} + * @memberof OSV1ImageStreamLayers + */ + images: { [key: string]: OSV1ImageBlobReferences }; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ImageStreamLayers + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1ImageStreamLayers + */ + metadata?: V1ObjectMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStreamList.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamList.ts new file mode 100644 index 00000000000..f41944882a3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageStream } from './OSV1ImageStream'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ImageStreamList is a list of ImageStream objects. + * @export + * @interface OSV1ImageStreamList + */ +export interface OSV1ImageStreamList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ImageStreamList + */ + apiVersion?: string; + /** + * Items is a list of imageStreams + * @type {Array} + * @memberof OSV1ImageStreamList + */ + items: OSV1ImageStream[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ImageStreamList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1ImageStreamList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStreamMapping.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamMapping.ts new file mode 100644 index 00000000000..f76a2c6e59f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamMapping.ts @@ -0,0 +1,53 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1Image } from './OSV1Image'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ImageStreamMapping represents a mapping from a single tag to a container image as well as the reference to the container image stream the image came from. + * @export + * @interface OSV1ImageStreamMapping + */ +export interface OSV1ImageStreamMapping { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ImageStreamMapping + */ + apiVersion?: string; + /** + * + * @type {OSV1Image} + * @memberof OSV1ImageStreamMapping + */ + image: OSV1Image; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ImageStreamMapping + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1ImageStreamMapping + */ + metadata?: V1ObjectMeta; + /** + * Tag is a string value this image can be located with inside the stream. + * @type {string} + * @memberof OSV1ImageStreamMapping + */ + tag: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStreamSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamSpec.ts new file mode 100644 index 00000000000..c9687ce9004 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamSpec.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageLookupPolicy } from './OSV1ImageLookupPolicy'; +import { OSV1TagReference } from './OSV1TagReference'; + +/** + * ImageStreamSpec represents options for ImageStreams. + * @export + * @interface OSV1ImageStreamSpec + */ +export interface OSV1ImageStreamSpec { + /** + * dockerImageRepository is optional, if specified this stream is backed by a container repository on this server Deprecated: This field is deprecated as of v3.7 and will be removed in a future release. Specify the source for the tags to be imported in each tag via the spec.tags.from reference instead. + * @type {string} + * @memberof OSV1ImageStreamSpec + */ + dockerImageRepository?: string; + /** + * + * @type {OSV1ImageLookupPolicy} + * @memberof OSV1ImageStreamSpec + */ + lookupPolicy?: OSV1ImageLookupPolicy; + /** + * tags map arbitrary string values to specific image locators + * @type {Array} + * @memberof OSV1ImageStreamSpec + */ + tags?: OSV1TagReference[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStreamStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamStatus.ts new file mode 100644 index 00000000000..f883a67db4e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamStatus.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1NamedTagEventList } from './OSV1NamedTagEventList'; + +/** + * ImageStreamStatus contains information about the state of this image stream. + * @export + * @interface OSV1ImageStreamStatus + */ +export interface OSV1ImageStreamStatus { + /** + * DockerImageRepository represents the effective location this stream may be accessed at. May be empty until the server determines where the repository is located + * @type {string} + * @memberof OSV1ImageStreamStatus + */ + dockerImageRepository: string; + /** + * PublicDockerImageRepository represents the public location from where the image can be pulled outside the cluster. This field may be empty if the administrator has not exposed the integrated registry externally. + * @type {string} + * @memberof OSV1ImageStreamStatus + */ + publicDockerImageRepository?: string; + /** + * Tags are a historical record of images associated with each tag. The first entry in the TagEvent array is the currently tagged image. + * @type {Array} + * @memberof OSV1ImageStreamStatus + */ + tags?: OSV1NamedTagEventList[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStreamTag.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamTag.ts new file mode 100644 index 00000000000..3ec67ec35e8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamTag.ts @@ -0,0 +1,74 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1Image } from './OSV1Image'; +import { OSV1ImageLookupPolicy } from './OSV1ImageLookupPolicy'; +import { OSV1TagEventCondition } from './OSV1TagEventCondition'; +import { OSV1TagReference } from './OSV1TagReference'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ImageStreamTag represents an Image that is retrieved by tag name from an ImageStream. + * @export + * @interface OSV1ImageStreamTag + */ +export interface OSV1ImageStreamTag { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ImageStreamTag + */ + apiVersion?: string; + /** + * conditions is an array of conditions that apply to the image stream tag. + * @type {Array} + * @memberof OSV1ImageStreamTag + */ + conditions?: OSV1TagEventCondition[]; + /** + * generation is the current generation of the tagged image - if tag is provided and this value is not equal to the tag generation, a user has requested an import that has not completed, or conditions will be filled out indicating any error. + * @type {number} + * @memberof OSV1ImageStreamTag + */ + generation: number; + /** + * + * @type {OSV1Image} + * @memberof OSV1ImageStreamTag + */ + image: OSV1Image; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ImageStreamTag + */ + kind?: string; + /** + * + * @type {OSV1ImageLookupPolicy} + * @memberof OSV1ImageStreamTag + */ + lookupPolicy: OSV1ImageLookupPolicy; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1ImageStreamTag + */ + metadata?: V1ObjectMeta; + /** + * + * @type {OSV1TagReference} + * @memberof OSV1ImageStreamTag + */ + tag: OSV1TagReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ImageStreamTagList.ts b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamTagList.ts new file mode 100644 index 00000000000..1497e5f2b54 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ImageStreamTagList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageStreamTag } from './OSV1ImageStreamTag'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ImageStreamTagList is a list of ImageStreamTag objects. + * @export + * @interface OSV1ImageStreamTagList + */ +export interface OSV1ImageStreamTagList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ImageStreamTagList + */ + apiVersion?: string; + /** + * Items is the list of image stream tags + * @type {Array} + * @memberof OSV1ImageStreamTagList + */ + items: OSV1ImageStreamTag[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ImageStreamTagList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1ImageStreamTagList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1JenkinsPipelineBuildStrategy.ts b/frontend/packages/kube-types/src/openshift/OSV1JenkinsPipelineBuildStrategy.ts new file mode 100644 index 00000000000..a7768b20cbe --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1JenkinsPipelineBuildStrategy.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1EnvVar } from './V1EnvVar'; + +/** + * JenkinsPipelineBuildStrategy holds parameters specific to a Jenkins Pipeline build. + * @export + * @interface OSV1JenkinsPipelineBuildStrategy + */ +export interface OSV1JenkinsPipelineBuildStrategy { + /** + * env contains additional environment variables you want to pass into a build pipeline. + * @type {Array} + * @memberof OSV1JenkinsPipelineBuildStrategy + */ + env?: V1EnvVar[]; + /** + * Jenkinsfile defines the optional raw contents of a Jenkinsfile which defines a Jenkins pipeline build. + * @type {string} + * @memberof OSV1JenkinsPipelineBuildStrategy + */ + jenkinsfile?: string; + /** + * JenkinsfilePath is the optional path of the Jenkinsfile that will be used to configure the pipeline relative to the root of the context (contextDir). If both JenkinsfilePath & Jenkinsfile are both not specified, this defaults to Jenkinsfile in the root of the specified contextDir. + * @type {string} + * @memberof OSV1JenkinsPipelineBuildStrategy + */ + jenkinsfilePath?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1LifecycleHook.ts b/frontend/packages/kube-types/src/openshift/OSV1LifecycleHook.ts new file mode 100644 index 00000000000..dab5e691e58 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1LifecycleHook.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ExecNewPodHook } from './OSV1ExecNewPodHook'; +import { OSV1TagImageHook } from './OSV1TagImageHook'; + +/** + * LifecycleHook defines a specific deployment lifecycle action. Only one type of action may be specified at any time. + * @export + * @interface OSV1LifecycleHook + */ +export interface OSV1LifecycleHook { + /** + * + * @type {OSV1ExecNewPodHook} + * @memberof OSV1LifecycleHook + */ + execNewPod?: OSV1ExecNewPodHook; + /** + * FailurePolicy specifies what action to take if the hook fails. + * @type {string} + * @memberof OSV1LifecycleHook + */ + failurePolicy: string; + /** + * TagImages instructs the deployer to tag the current image referenced under a container onto an image stream tag. + * @type {Array} + * @memberof OSV1LifecycleHook + */ + tagImages?: OSV1TagImageHook[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1LocalResourceAccessReview.ts b/frontend/packages/kube-types/src/openshift/OSV1LocalResourceAccessReview.ts new file mode 100644 index 00000000000..f2de54933b9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1LocalResourceAccessReview.ts @@ -0,0 +1,88 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { IoK8sApimachineryPkgRuntimeRawExtension } from './IoK8sApimachineryPkgRuntimeRawExtension'; + +/** + * LocalResourceAccessReview is a means to request a list of which users and groups are authorized to perform the action specified by spec in a particular namespace + * @export + * @interface OSV1LocalResourceAccessReview + */ +export interface OSV1LocalResourceAccessReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1LocalResourceAccessReview + */ + apiVersion?: string; + /** + * + * @type {IoK8sApimachineryPkgRuntimeRawExtension} + * @memberof OSV1LocalResourceAccessReview + */ + content?: IoK8sApimachineryPkgRuntimeRawExtension; + /** + * IsNonResourceURL is true if this is a request for a non-resource URL (outside of the resource hieraarchy) + * @type {boolean} + * @memberof OSV1LocalResourceAccessReview + */ + isNonResourceURL: boolean; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1LocalResourceAccessReview + */ + kind?: string; + /** + * Namespace is the namespace of the action being requested. Currently, there is no distinction between no namespace and all namespaces + * @type {string} + * @memberof OSV1LocalResourceAccessReview + */ + namespace: string; + /** + * Path is the path of a non resource URL + * @type {string} + * @memberof OSV1LocalResourceAccessReview + */ + path: string; + /** + * Resource is one of the existing resource types + * @type {string} + * @memberof OSV1LocalResourceAccessReview + */ + resource: string; + /** + * Group is the API group of the resource Serialized as resourceAPIGroup to avoid confusion with the \'groups\' field when inlined + * @type {string} + * @memberof OSV1LocalResourceAccessReview + */ + resourceAPIGroup: string; + /** + * Version is the API version of the resource Serialized as resourceAPIVersion to avoid confusion with TypeMeta.apiVersion and ObjectMeta.resourceVersion when inlined + * @type {string} + * @memberof OSV1LocalResourceAccessReview + */ + resourceAPIVersion: string; + /** + * ResourceName is the name of the resource being requested for a \"get\" or deleted for a \"delete\" + * @type {string} + * @memberof OSV1LocalResourceAccessReview + */ + resourceName: string; + /** + * Verb is one of: get, list, watch, create, update, delete + * @type {string} + * @memberof OSV1LocalResourceAccessReview + */ + verb: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1LocalSubjectAccessReview.ts b/frontend/packages/kube-types/src/openshift/OSV1LocalSubjectAccessReview.ts new file mode 100644 index 00000000000..1bd64e65ae0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1LocalSubjectAccessReview.ts @@ -0,0 +1,106 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { IoK8sApimachineryPkgRuntimeRawExtension } from './IoK8sApimachineryPkgRuntimeRawExtension'; + +/** + * LocalSubjectAccessReview is an object for requesting information about whether a user or group can perform an action in a particular namespace + * @export + * @interface OSV1LocalSubjectAccessReview + */ +export interface OSV1LocalSubjectAccessReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1LocalSubjectAccessReview + */ + apiVersion?: string; + /** + * + * @type {IoK8sApimachineryPkgRuntimeRawExtension} + * @memberof OSV1LocalSubjectAccessReview + */ + content?: IoK8sApimachineryPkgRuntimeRawExtension; + /** + * Groups is optional. Groups is the list of groups to which the User belongs. + * @type {Array} + * @memberof OSV1LocalSubjectAccessReview + */ + groups: string[]; + /** + * IsNonResourceURL is true if this is a request for a non-resource URL (outside of the resource hieraarchy) + * @type {boolean} + * @memberof OSV1LocalSubjectAccessReview + */ + isNonResourceURL: boolean; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1LocalSubjectAccessReview + */ + kind?: string; + /** + * Namespace is the namespace of the action being requested. Currently, there is no distinction between no namespace and all namespaces + * @type {string} + * @memberof OSV1LocalSubjectAccessReview + */ + namespace: string; + /** + * Path is the path of a non resource URL + * @type {string} + * @memberof OSV1LocalSubjectAccessReview + */ + path: string; + /** + * Resource is one of the existing resource types + * @type {string} + * @memberof OSV1LocalSubjectAccessReview + */ + resource: string; + /** + * Group is the API group of the resource Serialized as resourceAPIGroup to avoid confusion with the \'groups\' field when inlined + * @type {string} + * @memberof OSV1LocalSubjectAccessReview + */ + resourceAPIGroup: string; + /** + * Version is the API version of the resource Serialized as resourceAPIVersion to avoid confusion with TypeMeta.apiVersion and ObjectMeta.resourceVersion when inlined + * @type {string} + * @memberof OSV1LocalSubjectAccessReview + */ + resourceAPIVersion: string; + /** + * ResourceName is the name of the resource being requested for a \"get\" or deleted for a \"delete\" + * @type {string} + * @memberof OSV1LocalSubjectAccessReview + */ + resourceName: string; + /** + * Scopes to use for the evaluation. Empty means \"use the unscoped (full) permissions of the user/groups\". Nil for a self-SAR, means \"use the scopes on this request\". Nil for a regular SAR, means the same as empty. + * @type {Array} + * @memberof OSV1LocalSubjectAccessReview + */ + scopes: string[]; + /** + * User is optional. If both User and Groups are empty, the current authenticated user is used. + * @type {string} + * @memberof OSV1LocalSubjectAccessReview + */ + user: string; + /** + * Verb is one of: get, list, watch, create, update, delete + * @type {string} + * @memberof OSV1LocalSubjectAccessReview + */ + verb: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1NamedTagEventList.ts b/frontend/packages/kube-types/src/openshift/OSV1NamedTagEventList.ts new file mode 100644 index 00000000000..2d819937440 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1NamedTagEventList.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1TagEvent } from './OSV1TagEvent'; +import { OSV1TagEventCondition } from './OSV1TagEventCondition'; + +/** + * NamedTagEventList relates a tag to its image history. + * @export + * @interface OSV1NamedTagEventList + */ +export interface OSV1NamedTagEventList { + /** + * Conditions is an array of conditions that apply to the tag event list. + * @type {Array} + * @memberof OSV1NamedTagEventList + */ + conditions?: OSV1TagEventCondition[]; + /** + * Standard object\'s metadata. + * @type {Array} + * @memberof OSV1NamedTagEventList + */ + items: OSV1TagEvent[]; + /** + * Tag is the tag for which the history is recorded + * @type {string} + * @memberof OSV1NamedTagEventList + */ + tag: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1NetNamespace.ts b/frontend/packages/kube-types/src/openshift/OSV1NetNamespace.ts new file mode 100644 index 00000000000..4da49b8c8e8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1NetNamespace.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * NetNamespace describes a single isolated network. When using the redhat/openshift-ovs-multitenant plugin, every Namespace will have a corresponding NetNamespace object with the same name. (When using redhat/openshift-ovs-subnet, NetNamespaces are not used.) + * @export + * @interface OSV1NetNamespace + */ +export interface OSV1NetNamespace { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1NetNamespace + */ + apiVersion?: string; + /** + * EgressIPs is a list of reserved IPs that will be used as the source for external traffic coming from pods in this namespace. (If empty, external traffic will be masqueraded to Node IPs.) + * @type {Array} + * @memberof OSV1NetNamespace + */ + egressIPs?: string[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1NetNamespace + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1NetNamespace + */ + metadata?: V1ObjectMeta; + /** + * NetID is the network identifier of the network namespace assigned to each overlay network packet. This can be manipulated with the \"oc adm pod-network\" commands. + * @type {number} + * @memberof OSV1NetNamespace + */ + netid: number; + /** + * NetName is the name of the network namespace. (This is the same as the object\'s name, but both fields must be set.) + * @type {string} + * @memberof OSV1NetNamespace + */ + netname: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1NetNamespaceList.ts b/frontend/packages/kube-types/src/openshift/OSV1NetNamespaceList.ts new file mode 100644 index 00000000000..aeb9258ba69 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1NetNamespaceList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1NetNamespace } from './OSV1NetNamespace'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * NetNamespaceList is a collection of NetNamespaces + * @export + * @interface OSV1NetNamespaceList + */ +export interface OSV1NetNamespaceList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1NetNamespaceList + */ + apiVersion?: string; + /** + * Items is the list of net namespaces + * @type {Array} + * @memberof OSV1NetNamespaceList + */ + items: OSV1NetNamespace[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1NetNamespaceList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1NetNamespaceList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1OAuthAccessToken.ts b/frontend/packages/kube-types/src/openshift/OSV1OAuthAccessToken.ts new file mode 100644 index 00000000000..829672fe179 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1OAuthAccessToken.ts @@ -0,0 +1,94 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * OAuthAccessToken describes an OAuth access token + * @export + * @interface OSV1OAuthAccessToken + */ +export interface OSV1OAuthAccessToken { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1OAuthAccessToken + */ + apiVersion?: string; + /** + * AuthorizeToken contains the token that authorized this token + * @type {string} + * @memberof OSV1OAuthAccessToken + */ + authorizeToken?: string; + /** + * ClientName references the client that created this token. + * @type {string} + * @memberof OSV1OAuthAccessToken + */ + clientName?: string; + /** + * ExpiresIn is the seconds from CreationTime before this token expires. + * @type {number} + * @memberof OSV1OAuthAccessToken + */ + expiresIn?: number; + /** + * InactivityTimeoutSeconds is the value in seconds, from the CreationTimestamp, after which this token can no longer be used. The value is automatically incremented when the token is used. + * @type {number} + * @memberof OSV1OAuthAccessToken + */ + inactivityTimeoutSeconds?: number; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1OAuthAccessToken + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1OAuthAccessToken + */ + metadata?: V1ObjectMeta; + /** + * RedirectURI is the redirection associated with the token. + * @type {string} + * @memberof OSV1OAuthAccessToken + */ + redirectURI?: string; + /** + * RefreshToken is the value by which this token can be renewed. Can be blank. + * @type {string} + * @memberof OSV1OAuthAccessToken + */ + refreshToken?: string; + /** + * Scopes is an array of the requested scopes. + * @type {Array} + * @memberof OSV1OAuthAccessToken + */ + scopes?: string[]; + /** + * UserName is the user name associated with this token + * @type {string} + * @memberof OSV1OAuthAccessToken + */ + userName?: string; + /** + * UserUID is the unique UID associated with this token + * @type {string} + * @memberof OSV1OAuthAccessToken + */ + userUID?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1OAuthAccessTokenList.ts b/frontend/packages/kube-types/src/openshift/OSV1OAuthAccessTokenList.ts new file mode 100644 index 00000000000..ec8b507e542 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1OAuthAccessTokenList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1OAuthAccessToken } from './OSV1OAuthAccessToken'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * OAuthAccessTokenList is a collection of OAuth access tokens + * @export + * @interface OSV1OAuthAccessTokenList + */ +export interface OSV1OAuthAccessTokenList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1OAuthAccessTokenList + */ + apiVersion?: string; + /** + * Items is the list of OAuth access tokens + * @type {Array} + * @memberof OSV1OAuthAccessTokenList + */ + items: OSV1OAuthAccessToken[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1OAuthAccessTokenList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1OAuthAccessTokenList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1OAuthAuthorizeToken.ts b/frontend/packages/kube-types/src/openshift/OSV1OAuthAuthorizeToken.ts new file mode 100644 index 00000000000..327ed947325 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1OAuthAuthorizeToken.ts @@ -0,0 +1,94 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * OAuthAuthorizeToken describes an OAuth authorization token + * @export + * @interface OSV1OAuthAuthorizeToken + */ +export interface OSV1OAuthAuthorizeToken { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1OAuthAuthorizeToken + */ + apiVersion?: string; + /** + * ClientName references the client that created this token. + * @type {string} + * @memberof OSV1OAuthAuthorizeToken + */ + clientName?: string; + /** + * CodeChallenge is the optional code_challenge associated with this authorization code, as described in rfc7636 + * @type {string} + * @memberof OSV1OAuthAuthorizeToken + */ + codeChallenge?: string; + /** + * CodeChallengeMethod is the optional code_challenge_method associated with this authorization code, as described in rfc7636 + * @type {string} + * @memberof OSV1OAuthAuthorizeToken + */ + codeChallengeMethod?: string; + /** + * ExpiresIn is the seconds from CreationTime before this token expires. + * @type {number} + * @memberof OSV1OAuthAuthorizeToken + */ + expiresIn?: number; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1OAuthAuthorizeToken + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1OAuthAuthorizeToken + */ + metadata?: V1ObjectMeta; + /** + * RedirectURI is the redirection associated with the token. + * @type {string} + * @memberof OSV1OAuthAuthorizeToken + */ + redirectURI?: string; + /** + * Scopes is an array of the requested scopes. + * @type {Array} + * @memberof OSV1OAuthAuthorizeToken + */ + scopes?: string[]; + /** + * State data from request + * @type {string} + * @memberof OSV1OAuthAuthorizeToken + */ + state?: string; + /** + * UserName is the user name associated with this token + * @type {string} + * @memberof OSV1OAuthAuthorizeToken + */ + userName?: string; + /** + * UserUID is the unique UID associated with this token. UserUID and UserName must both match for this token to be valid. + * @type {string} + * @memberof OSV1OAuthAuthorizeToken + */ + userUID?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1OAuthAuthorizeTokenList.ts b/frontend/packages/kube-types/src/openshift/OSV1OAuthAuthorizeTokenList.ts new file mode 100644 index 00000000000..ad2d3c69854 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1OAuthAuthorizeTokenList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1OAuthAuthorizeToken } from './OSV1OAuthAuthorizeToken'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * OAuthAuthorizeTokenList is a collection of OAuth authorization tokens + * @export + * @interface OSV1OAuthAuthorizeTokenList + */ +export interface OSV1OAuthAuthorizeTokenList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1OAuthAuthorizeTokenList + */ + apiVersion?: string; + /** + * Items is the list of OAuth authorization tokens + * @type {Array} + * @memberof OSV1OAuthAuthorizeTokenList + */ + items: OSV1OAuthAuthorizeToken[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1OAuthAuthorizeTokenList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1OAuthAuthorizeTokenList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1OAuthClient.ts b/frontend/packages/kube-types/src/openshift/OSV1OAuthClient.ts new file mode 100644 index 00000000000..82275c33a07 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1OAuthClient.ts @@ -0,0 +1,89 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ScopeRestriction } from './OSV1ScopeRestriction'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * OAuthClient describes an OAuth client + * @export + * @interface OSV1OAuthClient + */ +export interface OSV1OAuthClient { + /** + * AccessTokenInactivityTimeoutSeconds overrides the default token inactivity timeout for tokens granted to this client. The value represents the maximum amount of time that can occur between consecutive uses of the token. Tokens become invalid if they are not used within this temporal window. The user will need to acquire a new token to regain access once a token times out. This value needs to be set only if the default set in configuration is not appropriate for this client. Valid values are: - 0: Tokens for this client never time out - X: Tokens time out if there is no activity for X seconds The current minimum allowed value for X is 300 (5 minutes) + * @type {number} + * @memberof OSV1OAuthClient + */ + accessTokenInactivityTimeoutSeconds?: number; + /** + * AccessTokenMaxAgeSeconds overrides the default access token max age for tokens granted to this client. 0 means no expiration. + * @type {number} + * @memberof OSV1OAuthClient + */ + accessTokenMaxAgeSeconds?: number; + /** + * AdditionalSecrets holds other secrets that may be used to identify the client. This is useful for rotation and for service account token validation + * @type {Array} + * @memberof OSV1OAuthClient + */ + additionalSecrets?: string[]; + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1OAuthClient + */ + apiVersion?: string; + /** + * GrantMethod determines how to handle grants for this client. If no method is provided, the cluster default grant handling method will be used. Valid grant handling methods are: - auto: always approves grant requests, useful for trusted clients - prompt: prompts the end user for approval of grant requests, useful for third-party clients - deny: always denies grant requests, useful for black-listed clients + * @type {string} + * @memberof OSV1OAuthClient + */ + grantMethod?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1OAuthClient + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1OAuthClient + */ + metadata?: V1ObjectMeta; + /** + * RedirectURIs is the valid redirection URIs associated with a client + * @type {Array} + * @memberof OSV1OAuthClient + */ + redirectURIs?: string[]; + /** + * RespondWithChallenges indicates whether the client wants authentication needed responses made in the form of challenges instead of redirects + * @type {boolean} + * @memberof OSV1OAuthClient + */ + respondWithChallenges?: boolean; + /** + * ScopeRestrictions describes which scopes this client can request. Each requested scope is checked against each restriction. If any restriction matches, then the scope is allowed. If no restriction matches, then the scope is denied. + * @type {Array} + * @memberof OSV1OAuthClient + */ + scopeRestrictions?: OSV1ScopeRestriction[]; + /** + * Secret is the unique secret associated with a client + * @type {string} + * @memberof OSV1OAuthClient + */ + secret?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1OAuthClientAuthorization.ts b/frontend/packages/kube-types/src/openshift/OSV1OAuthClientAuthorization.ts new file mode 100644 index 00000000000..be0c379313e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1OAuthClientAuthorization.ts @@ -0,0 +1,64 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * OAuthClientAuthorization describes an authorization created by an OAuth client + * @export + * @interface OSV1OAuthClientAuthorization + */ +export interface OSV1OAuthClientAuthorization { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1OAuthClientAuthorization + */ + apiVersion?: string; + /** + * ClientName references the client that created this authorization + * @type {string} + * @memberof OSV1OAuthClientAuthorization + */ + clientName?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1OAuthClientAuthorization + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1OAuthClientAuthorization + */ + metadata?: V1ObjectMeta; + /** + * Scopes is an array of the granted scopes. + * @type {Array} + * @memberof OSV1OAuthClientAuthorization + */ + scopes?: string[]; + /** + * UserName is the user name that authorized this client + * @type {string} + * @memberof OSV1OAuthClientAuthorization + */ + userName?: string; + /** + * UserUID is the unique UID associated with this authorization. UserUID and UserName must both match for this authorization to be valid. + * @type {string} + * @memberof OSV1OAuthClientAuthorization + */ + userUID?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1OAuthClientAuthorizationList.ts b/frontend/packages/kube-types/src/openshift/OSV1OAuthClientAuthorizationList.ts new file mode 100644 index 00000000000..74c1e107414 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1OAuthClientAuthorizationList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1OAuthClientAuthorization } from './OSV1OAuthClientAuthorization'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * OAuthClientAuthorizationList is a collection of OAuth client authorizations + * @export + * @interface OSV1OAuthClientAuthorizationList + */ +export interface OSV1OAuthClientAuthorizationList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1OAuthClientAuthorizationList + */ + apiVersion?: string; + /** + * Items is the list of OAuth client authorizations + * @type {Array} + * @memberof OSV1OAuthClientAuthorizationList + */ + items: OSV1OAuthClientAuthorization[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1OAuthClientAuthorizationList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1OAuthClientAuthorizationList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1OAuthClientList.ts b/frontend/packages/kube-types/src/openshift/OSV1OAuthClientList.ts new file mode 100644 index 00000000000..13a70946984 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1OAuthClientList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1OAuthClient } from './OSV1OAuthClient'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * OAuthClientList is a collection of OAuth clients + * @export + * @interface OSV1OAuthClientList + */ +export interface OSV1OAuthClientList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1OAuthClientList + */ + apiVersion?: string; + /** + * Items is the list of OAuth clients + * @type {Array} + * @memberof OSV1OAuthClientList + */ + items: OSV1OAuthClient[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1OAuthClientList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1OAuthClientList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReview.ts b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReview.ts new file mode 100644 index 00000000000..a720169dd5b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReview.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1PodSecurityPolicyReviewSpec } from './OSV1PodSecurityPolicyReviewSpec'; +import { OSV1PodSecurityPolicyReviewStatus } from './OSV1PodSecurityPolicyReviewStatus'; + +/** + * PodSecurityPolicyReview checks which service accounts (not users, since that would be cluster-wide) can create the `PodTemplateSpec` in question. + * @export + * @interface OSV1PodSecurityPolicyReview + */ +export interface OSV1PodSecurityPolicyReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1PodSecurityPolicyReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1PodSecurityPolicyReview + */ + kind?: string; + /** + * + * @type {OSV1PodSecurityPolicyReviewSpec} + * @memberof OSV1PodSecurityPolicyReview + */ + spec: OSV1PodSecurityPolicyReviewSpec; + /** + * + * @type {OSV1PodSecurityPolicyReviewStatus} + * @memberof OSV1PodSecurityPolicyReview + */ + status?: OSV1PodSecurityPolicyReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReviewSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReviewSpec.ts new file mode 100644 index 00000000000..19e2a6df04b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReviewSpec.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; + +/** + * PodSecurityPolicyReviewSpec defines specification for PodSecurityPolicyReview + * @export + * @interface OSV1PodSecurityPolicyReviewSpec + */ +export interface OSV1PodSecurityPolicyReviewSpec { + /** + * serviceAccountNames is an optional set of ServiceAccounts to run the check with. If serviceAccountNames is empty, the template.spec.serviceAccountName is used, unless it\'s empty, in which case \"default\" is used instead. If serviceAccountNames is specified, template.spec.serviceAccountName is ignored. + * @type {Array} + * @memberof OSV1PodSecurityPolicyReviewSpec + */ + serviceAccountNames?: string[]; + /** + * + * @type {V1PodTemplateSpec} + * @memberof OSV1PodSecurityPolicyReviewSpec + */ + template: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReviewStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReviewStatus.ts new file mode 100644 index 00000000000..77796cee984 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicyReviewStatus.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ServiceAccountPodSecurityPolicyReviewStatus } from './OSV1ServiceAccountPodSecurityPolicyReviewStatus'; + +/** + * PodSecurityPolicyReviewStatus represents the status of PodSecurityPolicyReview. + * @export + * @interface OSV1PodSecurityPolicyReviewStatus + */ +export interface OSV1PodSecurityPolicyReviewStatus { + /** + * allowedServiceAccounts returns the list of service accounts in *this* namespace that have the power to create the PodTemplateSpec. + * @type {Array} + * @memberof OSV1PodSecurityPolicyReviewStatus + */ + allowedServiceAccounts: OSV1ServiceAccountPodSecurityPolicyReviewStatus[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySelfSubjectReview.ts b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySelfSubjectReview.ts new file mode 100644 index 00000000000..6a3b475cbbe --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySelfSubjectReview.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1PodSecurityPolicySelfSubjectReviewSpec } from './OSV1PodSecurityPolicySelfSubjectReviewSpec'; +import { OSV1PodSecurityPolicySubjectReviewStatus } from './OSV1PodSecurityPolicySubjectReviewStatus'; + +/** + * PodSecurityPolicySelfSubjectReview checks whether this user/SA tuple can create the PodTemplateSpec + * @export + * @interface OSV1PodSecurityPolicySelfSubjectReview + */ +export interface OSV1PodSecurityPolicySelfSubjectReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1PodSecurityPolicySelfSubjectReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1PodSecurityPolicySelfSubjectReview + */ + kind?: string; + /** + * + * @type {OSV1PodSecurityPolicySelfSubjectReviewSpec} + * @memberof OSV1PodSecurityPolicySelfSubjectReview + */ + spec: OSV1PodSecurityPolicySelfSubjectReviewSpec; + /** + * + * @type {OSV1PodSecurityPolicySubjectReviewStatus} + * @memberof OSV1PodSecurityPolicySelfSubjectReview + */ + status?: OSV1PodSecurityPolicySubjectReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySelfSubjectReviewSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySelfSubjectReviewSpec.ts new file mode 100644 index 00000000000..53093b770d9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySelfSubjectReviewSpec.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; + +/** + * PodSecurityPolicySelfSubjectReviewSpec contains specification for PodSecurityPolicySelfSubjectReview. + * @export + * @interface OSV1PodSecurityPolicySelfSubjectReviewSpec + */ +export interface OSV1PodSecurityPolicySelfSubjectReviewSpec { + /** + * + * @type {V1PodTemplateSpec} + * @memberof OSV1PodSecurityPolicySelfSubjectReviewSpec + */ + template: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReview.ts b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReview.ts new file mode 100644 index 00000000000..eb8541c9858 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReview.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1PodSecurityPolicySubjectReviewSpec } from './OSV1PodSecurityPolicySubjectReviewSpec'; +import { OSV1PodSecurityPolicySubjectReviewStatus } from './OSV1PodSecurityPolicySubjectReviewStatus'; + +/** + * PodSecurityPolicySubjectReview checks whether a particular user/SA tuple can create the PodTemplateSpec. + * @export + * @interface OSV1PodSecurityPolicySubjectReview + */ +export interface OSV1PodSecurityPolicySubjectReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1PodSecurityPolicySubjectReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1PodSecurityPolicySubjectReview + */ + kind?: string; + /** + * + * @type {OSV1PodSecurityPolicySubjectReviewSpec} + * @memberof OSV1PodSecurityPolicySubjectReview + */ + spec: OSV1PodSecurityPolicySubjectReviewSpec; + /** + * + * @type {OSV1PodSecurityPolicySubjectReviewStatus} + * @memberof OSV1PodSecurityPolicySubjectReview + */ + status?: OSV1PodSecurityPolicySubjectReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReviewSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReviewSpec.ts new file mode 100644 index 00000000000..99d47f05336 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReviewSpec.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; + +/** + * PodSecurityPolicySubjectReviewSpec defines specification for PodSecurityPolicySubjectReview + * @export + * @interface OSV1PodSecurityPolicySubjectReviewSpec + */ +export interface OSV1PodSecurityPolicySubjectReviewSpec { + /** + * groups is the groups you\'re testing for. + * @type {Array} + * @memberof OSV1PodSecurityPolicySubjectReviewSpec + */ + groups?: string[]; + /** + * + * @type {V1PodTemplateSpec} + * @memberof OSV1PodSecurityPolicySubjectReviewSpec + */ + template: V1PodTemplateSpec; + /** + * user is the user you\'re testing for. If you specify \"user\" but not \"group\", then is it interpreted as \"What if user were not a member of any groups. If user and groups are empty, then the check is performed using *only* the serviceAccountName in the template. + * @type {string} + * @memberof OSV1PodSecurityPolicySubjectReviewSpec + */ + user?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReviewStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReviewStatus.ts new file mode 100644 index 00000000000..8f58245d06c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1PodSecurityPolicySubjectReviewStatus.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; + +/** + * PodSecurityPolicySubjectReviewStatus contains information/status for PodSecurityPolicySubjectReview. + * @export + * @interface OSV1PodSecurityPolicySubjectReviewStatus + */ +export interface OSV1PodSecurityPolicySubjectReviewStatus { + /** + * + * @type {V1ObjectReference} + * @memberof OSV1PodSecurityPolicySubjectReviewStatus + */ + allowedBy?: V1ObjectReference; + /** + * A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. + * @type {string} + * @memberof OSV1PodSecurityPolicySubjectReviewStatus + */ + reason?: string; + /** + * + * @type {V1PodTemplateSpec} + * @memberof OSV1PodSecurityPolicySubjectReviewStatus + */ + template?: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1PolicyRule.ts b/frontend/packages/kube-types/src/openshift/OSV1PolicyRule.ts new file mode 100644 index 00000000000..15361d4da61 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1PolicyRule.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { IoK8sApimachineryPkgRuntimeRawExtension } from './IoK8sApimachineryPkgRuntimeRawExtension'; + +/** + * PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. + * @export + * @interface OSV1PolicyRule + */ +export interface OSV1PolicyRule { + /** + * APIGroups is the name of the APIGroup that contains the resources. If this field is empty, then both kubernetes and origin API groups are assumed. That means that if an action is requested against one of the enumerated resources in either the kubernetes or the origin API group, the request will be allowed + * @type {Array} + * @memberof OSV1PolicyRule + */ + apiGroups: string[]; + /** + * + * @type {IoK8sApimachineryPkgRuntimeRawExtension} + * @memberof OSV1PolicyRule + */ + attributeRestrictions?: IoK8sApimachineryPkgRuntimeRawExtension; + /** + * NonResourceURLsSlice is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path This name is intentionally different than the internal type so that the DefaultConvert works nicely and because the ordering may be different. + * @type {Array} + * @memberof OSV1PolicyRule + */ + nonResourceURLs?: string[]; + /** + * ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. + * @type {Array} + * @memberof OSV1PolicyRule + */ + resourceNames?: string[]; + /** + * Resources is a list of resources this rule applies to. ResourceAll represents all resources. + * @type {Array} + * @memberof OSV1PolicyRule + */ + resources: string[]; + /** + * Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. VerbAll represents all kinds. + * @type {Array} + * @memberof OSV1PolicyRule + */ + verbs: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RangeAllocation.ts b/frontend/packages/kube-types/src/openshift/OSV1RangeAllocation.ts new file mode 100644 index 00000000000..3dea1bb1888 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RangeAllocation.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * RangeAllocation is used so we can easily expose a RangeAllocation typed for security group + * @export + * @interface OSV1RangeAllocation + */ +export interface OSV1RangeAllocation { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1RangeAllocation + */ + apiVersion?: string; + /** + * data is a byte array representing the serialized state of a range allocation. It is a bitmap with each bit set to one to represent a range is taken. + * @type {string} + * @memberof OSV1RangeAllocation + */ + data: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1RangeAllocation + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1RangeAllocation + */ + metadata?: V1ObjectMeta; + /** + * range is a string representing a unique label for a range of uids, \"1000000000-2000000000/10000\". + * @type {string} + * @memberof OSV1RangeAllocation + */ + range: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RangeAllocationList.ts b/frontend/packages/kube-types/src/openshift/OSV1RangeAllocationList.ts new file mode 100644 index 00000000000..3d756177ead --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RangeAllocationList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1RangeAllocation } from './OSV1RangeAllocation'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * RangeAllocationList is a list of RangeAllocations objects + * @export + * @interface OSV1RangeAllocationList + */ +export interface OSV1RangeAllocationList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1RangeAllocationList + */ + apiVersion?: string; + /** + * List of RangeAllocations. + * @type {Array} + * @memberof OSV1RangeAllocationList + */ + items: OSV1RangeAllocation[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1RangeAllocationList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1RangeAllocationList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RecreateDeploymentStrategyParams.ts b/frontend/packages/kube-types/src/openshift/OSV1RecreateDeploymentStrategyParams.ts new file mode 100644 index 00000000000..678298d79d5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RecreateDeploymentStrategyParams.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1LifecycleHook } from './OSV1LifecycleHook'; + +/** + * RecreateDeploymentStrategyParams are the input to the Recreate deployment strategy. + * @export + * @interface OSV1RecreateDeploymentStrategyParams + */ +export interface OSV1RecreateDeploymentStrategyParams { + /** + * + * @type {OSV1LifecycleHook} + * @memberof OSV1RecreateDeploymentStrategyParams + */ + mid?: OSV1LifecycleHook; + /** + * + * @type {OSV1LifecycleHook} + * @memberof OSV1RecreateDeploymentStrategyParams + */ + post?: OSV1LifecycleHook; + /** + * + * @type {OSV1LifecycleHook} + * @memberof OSV1RecreateDeploymentStrategyParams + */ + pre?: OSV1LifecycleHook; + /** + * TimeoutSeconds is the time to wait for updates before giving up. If the value is nil, a default will be used. + * @type {number} + * @memberof OSV1RecreateDeploymentStrategyParams + */ + timeoutSeconds?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RepositoryImportSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1RepositoryImportSpec.ts new file mode 100644 index 00000000000..397e5617fe2 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RepositoryImportSpec.ts @@ -0,0 +1,48 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1TagImportPolicy } from './OSV1TagImportPolicy'; +import { OSV1TagReferencePolicy } from './OSV1TagReferencePolicy'; +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * RepositoryImportSpec describes a request to import images from a container image repository. + * @export + * @interface OSV1RepositoryImportSpec + */ +export interface OSV1RepositoryImportSpec { + /** + * + * @type {V1ObjectReference} + * @memberof OSV1RepositoryImportSpec + */ + from: V1ObjectReference; + /** + * + * @type {OSV1TagImportPolicy} + * @memberof OSV1RepositoryImportSpec + */ + importPolicy?: OSV1TagImportPolicy; + /** + * IncludeManifest determines if the manifest for each image is returned in the response + * @type {boolean} + * @memberof OSV1RepositoryImportSpec + */ + includeManifest?: boolean; + /** + * + * @type {OSV1TagReferencePolicy} + * @memberof OSV1RepositoryImportSpec + */ + referencePolicy?: OSV1TagReferencePolicy; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RepositoryImportStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1RepositoryImportStatus.ts new file mode 100644 index 00000000000..2ef68fafb13 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RepositoryImportStatus.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ImageImportStatus } from './OSV1ImageImportStatus'; +import { V1Status } from './V1Status'; + +/** + * RepositoryImportStatus describes the result of an image repository import + * @export + * @interface OSV1RepositoryImportStatus + */ +export interface OSV1RepositoryImportStatus { + /** + * AdditionalTags are tags that exist in the repository but were not imported because a maximum limit of automatic imports was applied. + * @type {Array} + * @memberof OSV1RepositoryImportStatus + */ + additionalTags?: string[]; + /** + * Images is a list of images successfully retrieved by the import of the repository. + * @type {Array} + * @memberof OSV1RepositoryImportStatus + */ + images?: OSV1ImageImportStatus[]; + /** + * + * @type {V1Status} + * @memberof OSV1RepositoryImportStatus + */ + status?: V1Status; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ResourceAccessReview.ts b/frontend/packages/kube-types/src/openshift/OSV1ResourceAccessReview.ts new file mode 100644 index 00000000000..04febbd5230 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ResourceAccessReview.ts @@ -0,0 +1,88 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { IoK8sApimachineryPkgRuntimeRawExtension } from './IoK8sApimachineryPkgRuntimeRawExtension'; + +/** + * ResourceAccessReview is a means to request a list of which users and groups are authorized to perform the action specified by spec + * @export + * @interface OSV1ResourceAccessReview + */ +export interface OSV1ResourceAccessReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1ResourceAccessReview + */ + apiVersion?: string; + /** + * + * @type {IoK8sApimachineryPkgRuntimeRawExtension} + * @memberof OSV1ResourceAccessReview + */ + content?: IoK8sApimachineryPkgRuntimeRawExtension; + /** + * IsNonResourceURL is true if this is a request for a non-resource URL (outside of the resource hieraarchy) + * @type {boolean} + * @memberof OSV1ResourceAccessReview + */ + isNonResourceURL: boolean; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1ResourceAccessReview + */ + kind?: string; + /** + * Namespace is the namespace of the action being requested. Currently, there is no distinction between no namespace and all namespaces + * @type {string} + * @memberof OSV1ResourceAccessReview + */ + namespace: string; + /** + * Path is the path of a non resource URL + * @type {string} + * @memberof OSV1ResourceAccessReview + */ + path: string; + /** + * Resource is one of the existing resource types + * @type {string} + * @memberof OSV1ResourceAccessReview + */ + resource: string; + /** + * Group is the API group of the resource Serialized as resourceAPIGroup to avoid confusion with the \'groups\' field when inlined + * @type {string} + * @memberof OSV1ResourceAccessReview + */ + resourceAPIGroup: string; + /** + * Version is the API version of the resource Serialized as resourceAPIVersion to avoid confusion with TypeMeta.apiVersion and ObjectMeta.resourceVersion when inlined + * @type {string} + * @memberof OSV1ResourceAccessReview + */ + resourceAPIVersion: string; + /** + * ResourceName is the name of the resource being requested for a \"get\" or deleted for a \"delete\" + * @type {string} + * @memberof OSV1ResourceAccessReview + */ + resourceName: string; + /** + * Verb is one of: get, list, watch, create, update, delete + * @type {string} + * @memberof OSV1ResourceAccessReview + */ + verb: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ResourceQuotaStatusByNamespace.ts b/frontend/packages/kube-types/src/openshift/OSV1ResourceQuotaStatusByNamespace.ts new file mode 100644 index 00000000000..3670642e6c6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ResourceQuotaStatusByNamespace.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ResourceQuotaStatus } from './V1ResourceQuotaStatus'; + +/** + * ResourceQuotaStatusByNamespace gives status for a particular project + * @export + * @interface OSV1ResourceQuotaStatusByNamespace + */ +export interface OSV1ResourceQuotaStatusByNamespace { + /** + * Namespace the project this status applies to + * @type {string} + * @memberof OSV1ResourceQuotaStatusByNamespace + */ + namespace: string; + /** + * + * @type {V1ResourceQuotaStatus} + * @memberof OSV1ResourceQuotaStatusByNamespace + */ + status: V1ResourceQuotaStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1Role.ts b/frontend/packages/kube-types/src/openshift/OSV1Role.ts new file mode 100644 index 00000000000..5cf8bf44984 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1Role.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1PolicyRule } from './OSV1PolicyRule'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Role is a logical grouping of PolicyRules that can be referenced as a unit by RoleBindings. + * @export + * @interface OSV1Role + */ +export interface OSV1Role { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1Role + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1Role + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1Role + */ + metadata?: V1ObjectMeta; + /** + * Rules holds all the PolicyRules for this Role + * @type {Array} + * @memberof OSV1Role + */ + rules: OSV1PolicyRule[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RoleBinding.ts b/frontend/packages/kube-types/src/openshift/OSV1RoleBinding.ts new file mode 100644 index 00000000000..539acd00620 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RoleBinding.ts @@ -0,0 +1,65 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * RoleBinding references a Role, but not contain it. It can reference any Role in the same namespace or in the global namespace. It adds who information via (Users and Groups) OR Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace (excepting the master namespace which has power in all namespaces). + * @export + * @interface OSV1RoleBinding + */ +export interface OSV1RoleBinding { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1RoleBinding + */ + apiVersion?: string; + /** + * GroupNames holds all the groups directly bound to the role. This field should only be specified when supporting legacy clients and servers. See Subjects for further details. + * @type {Array} + * @memberof OSV1RoleBinding + */ + groupNames: string[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1RoleBinding + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1RoleBinding + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1RoleBinding + */ + roleRef: V1ObjectReference; + /** + * Subjects hold object references to authorize with this rule. This field is ignored if UserNames or GroupNames are specified to support legacy clients and servers. Thus newer clients that do not need to support backwards compatibility should send only fully qualified Subjects and should omit the UserNames and GroupNames fields. Clients that need to support backwards compatibility can use this field to build the UserNames and GroupNames. + * @type {Array} + * @memberof OSV1RoleBinding + */ + subjects: V1ObjectReference[]; + /** + * UserNames holds all the usernames directly bound to the role. This field should only be specified when supporting legacy clients and servers. See Subjects for further details. + * @type {Array} + * @memberof OSV1RoleBinding + */ + userNames: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RoleBindingList.ts b/frontend/packages/kube-types/src/openshift/OSV1RoleBindingList.ts new file mode 100644 index 00000000000..cdb027ab8ab --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RoleBindingList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1RoleBinding } from './OSV1RoleBinding'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * RoleBindingList is a collection of RoleBindings + * @export + * @interface OSV1RoleBindingList + */ +export interface OSV1RoleBindingList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1RoleBindingList + */ + apiVersion?: string; + /** + * Items is a list of RoleBindings + * @type {Array} + * @memberof OSV1RoleBindingList + */ + items: OSV1RoleBinding[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1RoleBindingList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1RoleBindingList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestriction.ts b/frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestriction.ts new file mode 100644 index 00000000000..09a3ea911fb --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestriction.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1RoleBindingRestrictionSpec } from './OSV1RoleBindingRestrictionSpec'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * RoleBindingRestriction is an object that can be matched against a subject (user, group, or service account) to determine whether rolebindings on that subject are allowed in the namespace to which the RoleBindingRestriction belongs. If any one of those RoleBindingRestriction objects matches a subject, rolebindings on that subject in the namespace are allowed. + * @export + * @interface OSV1RoleBindingRestriction + */ +export interface OSV1RoleBindingRestriction { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1RoleBindingRestriction + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1RoleBindingRestriction + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1RoleBindingRestriction + */ + metadata: V1ObjectMeta; + /** + * + * @type {OSV1RoleBindingRestrictionSpec} + * @memberof OSV1RoleBindingRestriction + */ + spec: OSV1RoleBindingRestrictionSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestrictionList.ts b/frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestrictionList.ts new file mode 100644 index 00000000000..09c76bc2821 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestrictionList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1RoleBindingRestriction } from './OSV1RoleBindingRestriction'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * RoleBindingRestrictionList is a collection of RoleBindingRestriction objects. + * @export + * @interface OSV1RoleBindingRestrictionList + */ +export interface OSV1RoleBindingRestrictionList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1RoleBindingRestrictionList + */ + apiVersion?: string; + /** + * Items is a list of RoleBindingRestriction objects. + * @type {Array} + * @memberof OSV1RoleBindingRestrictionList + */ + items: OSV1RoleBindingRestriction[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1RoleBindingRestrictionList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1RoleBindingRestrictionList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestrictionSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestrictionSpec.ts new file mode 100644 index 00000000000..b0116d2cad4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RoleBindingRestrictionSpec.ts @@ -0,0 +1,42 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1GroupRestriction } from './OSV1GroupRestriction'; +import { OSV1ServiceAccountRestriction } from './OSV1ServiceAccountRestriction'; +import { OSV1UserRestriction } from './OSV1UserRestriction'; + +/** + * RoleBindingRestrictionSpec defines a rolebinding restriction. Exactly one field must be non-nil. + * @export + * @interface OSV1RoleBindingRestrictionSpec + */ +export interface OSV1RoleBindingRestrictionSpec { + /** + * + * @type {OSV1GroupRestriction} + * @memberof OSV1RoleBindingRestrictionSpec + */ + grouprestriction: OSV1GroupRestriction; + /** + * + * @type {OSV1ServiceAccountRestriction} + * @memberof OSV1RoleBindingRestrictionSpec + */ + serviceaccountrestriction: OSV1ServiceAccountRestriction; + /** + * + * @type {OSV1UserRestriction} + * @memberof OSV1RoleBindingRestrictionSpec + */ + userrestriction: OSV1UserRestriction; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RoleList.ts b/frontend/packages/kube-types/src/openshift/OSV1RoleList.ts new file mode 100644 index 00000000000..e310f4deae8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RoleList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1Role } from './OSV1Role'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * RoleList is a collection of Roles + * @export + * @interface OSV1RoleList + */ +export interface OSV1RoleList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1RoleList + */ + apiVersion?: string; + /** + * Items is a list of Roles + * @type {Array} + * @memberof OSV1RoleList + */ + items: OSV1Role[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1RoleList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1RoleList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RollingDeploymentStrategyParams.ts b/frontend/packages/kube-types/src/openshift/OSV1RollingDeploymentStrategyParams.ts new file mode 100644 index 00000000000..34ebaf69626 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RollingDeploymentStrategyParams.ts @@ -0,0 +1,64 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1LifecycleHook } from './OSV1LifecycleHook'; + +/** + * RollingDeploymentStrategyParams are the input to the Rolling deployment strategy. + * @export + * @interface OSV1RollingDeploymentStrategyParams + */ +export interface OSV1RollingDeploymentStrategyParams { + /** + * IntervalSeconds is the time to wait between polling deployment status after update. If the value is nil, a default will be used. + * @type {number} + * @memberof OSV1RollingDeploymentStrategyParams + */ + intervalSeconds?: number; + /** + * + * @type {string} + * @memberof OSV1RollingDeploymentStrategyParams + */ + maxSurge?: string; + /** + * + * @type {string} + * @memberof OSV1RollingDeploymentStrategyParams + */ + maxUnavailable?: string; + /** + * + * @type {OSV1LifecycleHook} + * @memberof OSV1RollingDeploymentStrategyParams + */ + post?: OSV1LifecycleHook; + /** + * + * @type {OSV1LifecycleHook} + * @memberof OSV1RollingDeploymentStrategyParams + */ + pre?: OSV1LifecycleHook; + /** + * TimeoutSeconds is the time to wait for updates before giving up. If the value is nil, a default will be used. + * @type {number} + * @memberof OSV1RollingDeploymentStrategyParams + */ + timeoutSeconds?: number; + /** + * UpdatePeriodSeconds is the time to wait between individual pod updates. If the value is nil, a default will be used. + * @type {number} + * @memberof OSV1RollingDeploymentStrategyParams + */ + updatePeriodSeconds?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1RunAsUserStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/OSV1RunAsUserStrategyOptions.ts new file mode 100644 index 00000000000..b6c5fc644ec --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1RunAsUserStrategyOptions.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy. + * @export + * @interface OSV1RunAsUserStrategyOptions + */ +export interface OSV1RunAsUserStrategyOptions { + /** + * Type is the strategy that will dictate what RunAsUser is used in the SecurityContext. + * @type {string} + * @memberof OSV1RunAsUserStrategyOptions + */ + type?: string; + /** + * UID is the user id that containers must run as. Required for the MustRunAs strategy if not using namespace/service account allocated uids. + * @type {number} + * @memberof OSV1RunAsUserStrategyOptions + */ + uid?: number; + /** + * UIDRangeMax defines the max value for a strategy that allocates by range. + * @type {number} + * @memberof OSV1RunAsUserStrategyOptions + */ + uidRangeMax?: number; + /** + * UIDRangeMin defines the min value for a strategy that allocates by range. + * @type {number} + * @memberof OSV1RunAsUserStrategyOptions + */ + uidRangeMin?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SELinuxContextStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/OSV1SELinuxContextStrategyOptions.ts new file mode 100644 index 00000000000..4230a056f82 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SELinuxContextStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SELinuxOptions } from './V1SELinuxOptions'; + +/** + * SELinuxContextStrategyOptions defines the strategy type and any options used to create the strategy. + * @export + * @interface OSV1SELinuxContextStrategyOptions + */ +export interface OSV1SELinuxContextStrategyOptions { + /** + * + * @type {V1SELinuxOptions} + * @memberof OSV1SELinuxContextStrategyOptions + */ + seLinuxOptions?: V1SELinuxOptions; + /** + * Type is the strategy that will dictate what SELinux context is used in the SecurityContext. + * @type {string} + * @memberof OSV1SELinuxContextStrategyOptions + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ScopeRestriction.ts b/frontend/packages/kube-types/src/openshift/OSV1ScopeRestriction.ts new file mode 100644 index 00000000000..4d6fb40685e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ScopeRestriction.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ClusterRoleScopeRestriction } from './OSV1ClusterRoleScopeRestriction'; + +/** + * ScopeRestriction describe one restriction on scopes. Exactly one option must be non-nil. + * @export + * @interface OSV1ScopeRestriction + */ +export interface OSV1ScopeRestriction { + /** + * + * @type {OSV1ClusterRoleScopeRestriction} + * @memberof OSV1ScopeRestriction + */ + clusterRole?: OSV1ClusterRoleScopeRestriction; + /** + * ExactValues means the scope has to match a particular set of strings exactly + * @type {Array} + * @memberof OSV1ScopeRestriction + */ + literals?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SecretBuildSource.ts b/frontend/packages/kube-types/src/openshift/OSV1SecretBuildSource.ts new file mode 100644 index 00000000000..a363f1cec0f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SecretBuildSource.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * SecretBuildSource describes a secret and its destination directory that will be used only at the build time. The content of the secret referenced here will be copied into the destination directory instead of mounting. + * @export + * @interface OSV1SecretBuildSource + */ +export interface OSV1SecretBuildSource { + /** + * destinationDir is the directory where the files from the secret should be available for the build time. For the Source build strategy, these will be injected into a container where the assemble script runs. Later, when the script finishes, all files injected will be truncated to zero length. For the container image build strategy, these will be copied into the build directory, where the Dockerfile is located, so users can ADD or COPY them during container image build. + * @type {string} + * @memberof OSV1SecretBuildSource + */ + destinationDir?: string; + /** + * + * @type {V1LocalObjectReference} + * @memberof OSV1SecretBuildSource + */ + secret: V1LocalObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SecretLocalReference.ts b/frontend/packages/kube-types/src/openshift/OSV1SecretLocalReference.ts new file mode 100644 index 00000000000..2b64a743bef --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SecretLocalReference.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SecretLocalReference contains information that points to the local secret being used + * @export + * @interface OSV1SecretLocalReference + */ +export interface OSV1SecretLocalReference { + /** + * Name is the name of the resource in the same namespace being referenced + * @type {string} + * @memberof OSV1SecretLocalReference + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SecretSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1SecretSpec.ts new file mode 100644 index 00000000000..3a55b444e20 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SecretSpec.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * SecretSpec specifies a secret to be included in a build pod and its corresponding mount point + * @export + * @interface OSV1SecretSpec + */ +export interface OSV1SecretSpec { + /** + * mountPath is the path at which to mount the secret + * @type {string} + * @memberof OSV1SecretSpec + */ + mountPath: string; + /** + * + * @type {V1LocalObjectReference} + * @memberof OSV1SecretSpec + */ + secretSource: V1LocalObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SecurityContextConstraints.ts b/frontend/packages/kube-types/src/openshift/OSV1SecurityContextConstraints.ts new file mode 100644 index 00000000000..03b0dd32731 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SecurityContextConstraints.ts @@ -0,0 +1,189 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1AllowedFlexVolume } from './OSV1AllowedFlexVolume'; +import { OSV1FSGroupStrategyOptions } from './OSV1FSGroupStrategyOptions'; +import { OSV1RunAsUserStrategyOptions } from './OSV1RunAsUserStrategyOptions'; +import { OSV1SELinuxContextStrategyOptions } from './OSV1SELinuxContextStrategyOptions'; +import { OSV1SupplementalGroupsStrategyOptions } from './OSV1SupplementalGroupsStrategyOptions'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * SecurityContextConstraints governs the ability to make requests that affect the SecurityContext that will be applied to a container. For historical reasons SCC was exposed under the core Kubernetes API group. That exposure is deprecated and will be removed in a future release - users should instead use the security.openshift.io group to manage SecurityContextConstraints. + * @export + * @interface OSV1SecurityContextConstraints + */ +export interface OSV1SecurityContextConstraints { + /** + * AllowHostDirVolumePlugin determines if the policy allow containers to use the HostDir volume plugin + * @type {boolean} + * @memberof OSV1SecurityContextConstraints + */ + allowHostDirVolumePlugin: boolean; + /** + * AllowHostIPC determines if the policy allows host ipc in the containers. + * @type {boolean} + * @memberof OSV1SecurityContextConstraints + */ + allowHostIPC: boolean; + /** + * AllowHostNetwork determines if the policy allows the use of HostNetwork in the pod spec. + * @type {boolean} + * @memberof OSV1SecurityContextConstraints + */ + allowHostNetwork: boolean; + /** + * AllowHostPID determines if the policy allows host pid in the containers. + * @type {boolean} + * @memberof OSV1SecurityContextConstraints + */ + allowHostPID: boolean; + /** + * AllowHostPorts determines if the policy allows host ports in the containers. + * @type {boolean} + * @memberof OSV1SecurityContextConstraints + */ + allowHostPorts: boolean; + /** + * AllowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true. + * @type {boolean} + * @memberof OSV1SecurityContextConstraints + */ + allowPrivilegeEscalation?: boolean; + /** + * AllowPrivilegedContainer determines if a container can request to be run as privileged. + * @type {boolean} + * @memberof OSV1SecurityContextConstraints + */ + allowPrivilegedContainer: boolean; + /** + * AllowedCapabilities is a list of capabilities that can be requested to add to the container. Capabilities in this field maybe added at the pod author\'s discretion. You must not list a capability in both AllowedCapabilities and RequiredDropCapabilities. To allow all capabilities you may use \'*\'. + * @type {Array} + * @memberof OSV1SecurityContextConstraints + */ + allowedCapabilities: string[]; + /** + * AllowedFlexVolumes is a whitelist of allowed Flexvolumes. Empty or nil indicates that all Flexvolumes may be used. This parameter is effective only when the usage of the Flexvolumes is allowed in the \"Volumes\" field. + * @type {Array} + * @memberof OSV1SecurityContextConstraints + */ + allowedFlexVolumes?: OSV1AllowedFlexVolume[]; + /** + * AllowedUnsafeSysctls is a list of explicitly allowed unsafe sysctls, defaults to none. Each entry is either a plain sysctl name or ends in \"*\" in which case it is considered as a prefix of allowed sysctls. Single * means all unsafe sysctls are allowed. Kubelet has to whitelist all allowed unsafe sysctls explicitly to avoid rejection. Examples: e.g. \"foo/_*\" allows \"foo/bar\", \"foo/baz\", etc. e.g. \"foo.*\" allows \"foo.bar\", \"foo.baz\", etc. + * @type {Array} + * @memberof OSV1SecurityContextConstraints + */ + allowedUnsafeSysctls?: string[]; + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1SecurityContextConstraints + */ + apiVersion?: string; + /** + * DefaultAddCapabilities is the default set of capabilities that will be added to the container unless the pod spec specifically drops the capability. You may not list a capabiility in both DefaultAddCapabilities and RequiredDropCapabilities. + * @type {Array} + * @memberof OSV1SecurityContextConstraints + */ + defaultAddCapabilities: string[]; + /** + * DefaultAllowPrivilegeEscalation controls the default setting for whether a process can gain more privileges than its parent process. + * @type {boolean} + * @memberof OSV1SecurityContextConstraints + */ + defaultAllowPrivilegeEscalation?: boolean; + /** + * ForbiddenSysctls is a list of explicitly forbidden sysctls, defaults to none. Each entry is either a plain sysctl name or ends in \"*\" in which case it is considered as a prefix of forbidden sysctls. Single * means all sysctls are forbidden. Examples: e.g. \"foo/_*\" forbids \"foo/bar\", \"foo/baz\", etc. e.g. \"foo.*\" forbids \"foo.bar\", \"foo.baz\", etc. + * @type {Array} + * @memberof OSV1SecurityContextConstraints + */ + forbiddenSysctls?: string[]; + /** + * + * @type {OSV1FSGroupStrategyOptions} + * @memberof OSV1SecurityContextConstraints + */ + fsGroup?: OSV1FSGroupStrategyOptions; + /** + * The groups that have permission to use this security context constraints + * @type {Array} + * @memberof OSV1SecurityContextConstraints + */ + groups?: string[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1SecurityContextConstraints + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1SecurityContextConstraints + */ + metadata?: V1ObjectMeta; + /** + * Priority influences the sort order of SCCs when evaluating which SCCs to try first for a given pod request based on access in the Users and Groups fields. The higher the int, the higher priority. An unset value is considered a 0 priority. If scores for multiple SCCs are equal they will be sorted from most restrictive to least restrictive. If both priorities and restrictions are equal the SCCs will be sorted by name. + * @type {number} + * @memberof OSV1SecurityContextConstraints + */ + priority: number; + /** + * ReadOnlyRootFilesystem when set to true will force containers to run with a read only root file system. If the container specifically requests to run with a non-read only root file system the SCC should deny the pod. If set to false the container may run with a read only root file system if it wishes but it will not be forced to. + * @type {boolean} + * @memberof OSV1SecurityContextConstraints + */ + readOnlyRootFilesystem: boolean; + /** + * RequiredDropCapabilities are the capabilities that will be dropped from the container. These are required to be dropped and cannot be added. + * @type {Array} + * @memberof OSV1SecurityContextConstraints + */ + requiredDropCapabilities: string[]; + /** + * + * @type {OSV1RunAsUserStrategyOptions} + * @memberof OSV1SecurityContextConstraints + */ + runAsUser?: OSV1RunAsUserStrategyOptions; + /** + * + * @type {OSV1SELinuxContextStrategyOptions} + * @memberof OSV1SecurityContextConstraints + */ + seLinuxContext?: OSV1SELinuxContextStrategyOptions; + /** + * SeccompProfiles lists the allowed profiles that may be set for the pod or container\'s seccomp annotations. An unset (nil) or empty value means that no profiles may be specifid by the pod or container. The wildcard \'*\' may be used to allow all profiles. When used to generate a value for a pod the first non-wildcard profile will be used as the default. + * @type {Array} + * @memberof OSV1SecurityContextConstraints + */ + seccompProfiles?: string[]; + /** + * + * @type {OSV1SupplementalGroupsStrategyOptions} + * @memberof OSV1SecurityContextConstraints + */ + supplementalGroups?: OSV1SupplementalGroupsStrategyOptions; + /** + * The users who have permissions to use this security context constraints + * @type {Array} + * @memberof OSV1SecurityContextConstraints + */ + users?: string[]; + /** + * Volumes is a white list of allowed volume plugins. FSType corresponds directly with the field names of a VolumeSource (azureFile, configMap, emptyDir). To allow all volumes you may use \"*\". To allow no volumes, set to [\"none\"]. + * @type {Array} + * @memberof OSV1SecurityContextConstraints + */ + volumes: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SecurityContextConstraintsList.ts b/frontend/packages/kube-types/src/openshift/OSV1SecurityContextConstraintsList.ts new file mode 100644 index 00000000000..10f218b5457 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SecurityContextConstraintsList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1SecurityContextConstraints } from './OSV1SecurityContextConstraints'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * SecurityContextConstraintsList is a list of SecurityContextConstraints objects + * @export + * @interface OSV1SecurityContextConstraintsList + */ +export interface OSV1SecurityContextConstraintsList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1SecurityContextConstraintsList + */ + apiVersion?: string; + /** + * List of security context constraints. + * @type {Array} + * @memberof OSV1SecurityContextConstraintsList + */ + items: OSV1SecurityContextConstraints[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1SecurityContextConstraintsList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1SecurityContextConstraintsList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SelfSubjectRulesReview.ts b/frontend/packages/kube-types/src/openshift/OSV1SelfSubjectRulesReview.ts new file mode 100644 index 00000000000..81cca7590cc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SelfSubjectRulesReview.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1SelfSubjectRulesReviewSpec } from './OSV1SelfSubjectRulesReviewSpec'; +import { OSV1SubjectRulesReviewStatus } from './OSV1SubjectRulesReviewStatus'; + +/** + * SelfSubjectRulesReview is a resource you can create to determine which actions you can perform in a namespace + * @export + * @interface OSV1SelfSubjectRulesReview + */ +export interface OSV1SelfSubjectRulesReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1SelfSubjectRulesReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1SelfSubjectRulesReview + */ + kind?: string; + /** + * + * @type {OSV1SelfSubjectRulesReviewSpec} + * @memberof OSV1SelfSubjectRulesReview + */ + spec: OSV1SelfSubjectRulesReviewSpec; + /** + * + * @type {OSV1SubjectRulesReviewStatus} + * @memberof OSV1SelfSubjectRulesReview + */ + status?: OSV1SubjectRulesReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SelfSubjectRulesReviewSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1SelfSubjectRulesReviewSpec.ts new file mode 100644 index 00000000000..e1d7cc9ec08 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SelfSubjectRulesReviewSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SelfSubjectRulesReviewSpec adds information about how to conduct the check + * @export + * @interface OSV1SelfSubjectRulesReviewSpec + */ +export interface OSV1SelfSubjectRulesReviewSpec { + /** + * Scopes to use for the evaluation. Empty means \"use the unscoped (full) permissions of the user/groups\". Nil means \"use the scopes on this request\". + * @type {Array} + * @memberof OSV1SelfSubjectRulesReviewSpec + */ + scopes: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ServiceAccountPodSecurityPolicyReviewStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1ServiceAccountPodSecurityPolicyReviewStatus.ts new file mode 100644 index 00000000000..e3a2b14ddf7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ServiceAccountPodSecurityPolicyReviewStatus.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; + +/** + * ServiceAccountPodSecurityPolicyReviewStatus represents ServiceAccount name and related review status + * @export + * @interface OSV1ServiceAccountPodSecurityPolicyReviewStatus + */ +export interface OSV1ServiceAccountPodSecurityPolicyReviewStatus { + /** + * + * @type {V1ObjectReference} + * @memberof OSV1ServiceAccountPodSecurityPolicyReviewStatus + */ + allowedBy?: V1ObjectReference; + /** + * name contains the allowed and the denied ServiceAccount name + * @type {string} + * @memberof OSV1ServiceAccountPodSecurityPolicyReviewStatus + */ + name: string; + /** + * A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. + * @type {string} + * @memberof OSV1ServiceAccountPodSecurityPolicyReviewStatus + */ + reason?: string; + /** + * + * @type {V1PodTemplateSpec} + * @memberof OSV1ServiceAccountPodSecurityPolicyReviewStatus + */ + template?: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ServiceAccountReference.ts b/frontend/packages/kube-types/src/openshift/OSV1ServiceAccountReference.ts new file mode 100644 index 00000000000..e070c015e08 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ServiceAccountReference.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ServiceAccountReference specifies a service account and namespace by their names. + * @export + * @interface OSV1ServiceAccountReference + */ +export interface OSV1ServiceAccountReference { + /** + * Name is the name of the service account. + * @type {string} + * @memberof OSV1ServiceAccountReference + */ + name: string; + /** + * Namespace is the namespace of the service account. Service accounts from inside the whitelisted namespaces are allowed to be bound to roles. If Namespace is empty, then the namespace of the RoleBindingRestriction in which the ServiceAccountReference is embedded is used. + * @type {string} + * @memberof OSV1ServiceAccountReference + */ + namespace: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1ServiceAccountRestriction.ts b/frontend/packages/kube-types/src/openshift/OSV1ServiceAccountRestriction.ts new file mode 100644 index 00000000000..0511af41f63 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1ServiceAccountRestriction.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1ServiceAccountReference } from './OSV1ServiceAccountReference'; + +/** + * ServiceAccountRestriction matches a service account by a string match on either the service-account name or the name of the service account\'s namespace. + * @export + * @interface OSV1ServiceAccountRestriction + */ +export interface OSV1ServiceAccountRestriction { + /** + * Namespaces specifies a list of literal namespace names. + * @type {Array} + * @memberof OSV1ServiceAccountRestriction + */ + namespaces: string[]; + /** + * ServiceAccounts specifies a list of literal service-account names. + * @type {Array} + * @memberof OSV1ServiceAccountRestriction + */ + serviceaccounts: OSV1ServiceAccountReference[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SignatureCondition.ts b/frontend/packages/kube-types/src/openshift/OSV1SignatureCondition.ts new file mode 100644 index 00000000000..db9703d00ce --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SignatureCondition.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SignatureCondition describes an image signature condition of particular kind at particular probe time. + * @export + * @interface OSV1SignatureCondition + */ +export interface OSV1SignatureCondition { + /** + * + * @type {string} + * @memberof OSV1SignatureCondition + */ + lastProbeTime?: string; + /** + * + * @type {string} + * @memberof OSV1SignatureCondition + */ + lastTransitionTime?: string; + /** + * Human readable message indicating details about last transition. + * @type {string} + * @memberof OSV1SignatureCondition + */ + message?: string; + /** + * (brief) reason for the condition\'s last transition. + * @type {string} + * @memberof OSV1SignatureCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof OSV1SignatureCondition + */ + status: string; + /** + * Type of signature condition, Complete or Failed. + * @type {string} + * @memberof OSV1SignatureCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SignatureIssuer.ts b/frontend/packages/kube-types/src/openshift/OSV1SignatureIssuer.ts new file mode 100644 index 00000000000..64577904834 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SignatureIssuer.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SignatureIssuer holds information about an issuer of signing certificate or key. + * @export + * @interface OSV1SignatureIssuer + */ +export interface OSV1SignatureIssuer { + /** + * Common name (e.g. openshift-signing-service). + * @type {string} + * @memberof OSV1SignatureIssuer + */ + commonName?: string; + /** + * Organization name. + * @type {string} + * @memberof OSV1SignatureIssuer + */ + organization?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SignatureSubject.ts b/frontend/packages/kube-types/src/openshift/OSV1SignatureSubject.ts new file mode 100644 index 00000000000..3dd83841787 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SignatureSubject.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SignatureSubject holds information about a person or entity who created the signature. + * @export + * @interface OSV1SignatureSubject + */ +export interface OSV1SignatureSubject { + /** + * Common name (e.g. openshift-signing-service). + * @type {string} + * @memberof OSV1SignatureSubject + */ + commonName?: string; + /** + * Organization name. + * @type {string} + * @memberof OSV1SignatureSubject + */ + organization?: string; + /** + * If present, it is a human readable key id of public key belonging to the subject used to verify image signature. It should contain at least 64 lowest bits of public key\'s fingerprint (e.g. 0x685ebe62bf278440). + * @type {string} + * @memberof OSV1SignatureSubject + */ + publicKeyID: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SourceBuildStrategy.ts b/frontend/packages/kube-types/src/openshift/OSV1SourceBuildStrategy.ts new file mode 100644 index 00000000000..f721d388819 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SourceBuildStrategy.ts @@ -0,0 +1,60 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1EnvVar } from './V1EnvVar'; +import { V1LocalObjectReference } from './V1LocalObjectReference'; +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * SourceBuildStrategy defines input parameters specific to an Source build. + * @export + * @interface OSV1SourceBuildStrategy + */ +export interface OSV1SourceBuildStrategy { + /** + * env contains additional environment variables you want to pass into a builder container. + * @type {Array} + * @memberof OSV1SourceBuildStrategy + */ + env?: V1EnvVar[]; + /** + * forcePull describes if the builder should pull the images from registry prior to building. + * @type {boolean} + * @memberof OSV1SourceBuildStrategy + */ + forcePull?: boolean; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1SourceBuildStrategy + */ + from: V1ObjectReference; + /** + * incremental flag forces the Source build to do incremental builds if true. + * @type {boolean} + * @memberof OSV1SourceBuildStrategy + */ + incremental?: boolean; + /** + * + * @type {V1LocalObjectReference} + * @memberof OSV1SourceBuildStrategy + */ + pullSecret?: V1LocalObjectReference; + /** + * scripts is the location of Source scripts + * @type {string} + * @memberof OSV1SourceBuildStrategy + */ + scripts?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SourceControlUser.ts b/frontend/packages/kube-types/src/openshift/OSV1SourceControlUser.ts new file mode 100644 index 00000000000..6aac1c79e93 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SourceControlUser.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SourceControlUser defines the identity of a user of source control + * @export + * @interface OSV1SourceControlUser + */ +export interface OSV1SourceControlUser { + /** + * email of the source control user + * @type {string} + * @memberof OSV1SourceControlUser + */ + email?: string; + /** + * name of the source control user + * @type {string} + * @memberof OSV1SourceControlUser + */ + name?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SourceRevision.ts b/frontend/packages/kube-types/src/openshift/OSV1SourceRevision.ts new file mode 100644 index 00000000000..5e3ca4bad30 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SourceRevision.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1GitSourceRevision } from './OSV1GitSourceRevision'; + +/** + * SourceRevision is the revision or commit information from the source for the build + * @export + * @interface OSV1SourceRevision + */ +export interface OSV1SourceRevision { + /** + * + * @type {OSV1GitSourceRevision} + * @memberof OSV1SourceRevision + */ + git?: OSV1GitSourceRevision; + /** + * type of the build source, may be one of \'Source\', \'Dockerfile\', \'Binary\', or \'Images\' + * @type {string} + * @memberof OSV1SourceRevision + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SourceStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/OSV1SourceStrategyOptions.ts new file mode 100644 index 00000000000..23550fe9086 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SourceStrategyOptions.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SourceStrategyOptions contains extra strategy options for Source builds + * @export + * @interface OSV1SourceStrategyOptions + */ +export interface OSV1SourceStrategyOptions { + /** + * incremental overrides the source-strategy incremental option in the build config + * @type {boolean} + * @memberof OSV1SourceStrategyOptions + */ + incremental?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1StageInfo.ts b/frontend/packages/kube-types/src/openshift/OSV1StageInfo.ts new file mode 100644 index 00000000000..3030387eb82 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1StageInfo.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1StepInfo } from './OSV1StepInfo'; + +/** + * StageInfo contains details about a build stage. + * @export + * @interface OSV1StageInfo + */ +export interface OSV1StageInfo { + /** + * durationMilliseconds identifies how long the stage took to complete in milliseconds. Note: the duration of a stage can exceed the sum of the duration of the steps within the stage as not all actions are accounted for in explicit build steps. + * @type {number} + * @memberof OSV1StageInfo + */ + durationMilliseconds?: number; + /** + * name is a unique identifier for each build stage that occurs. + * @type {string} + * @memberof OSV1StageInfo + */ + name?: string; + /** + * + * @type {string} + * @memberof OSV1StageInfo + */ + startTime?: string; + /** + * steps contains details about each step that occurs during a build stage including start time and duration in milliseconds. + * @type {Array} + * @memberof OSV1StageInfo + */ + steps?: OSV1StepInfo[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1StepInfo.ts b/frontend/packages/kube-types/src/openshift/OSV1StepInfo.ts new file mode 100644 index 00000000000..f501949894b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1StepInfo.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * StepInfo contains details about a build step. + * @export + * @interface OSV1StepInfo + */ +export interface OSV1StepInfo { + /** + * durationMilliseconds identifies how long the step took to complete in milliseconds. + * @type {number} + * @memberof OSV1StepInfo + */ + durationMilliseconds?: number; + /** + * name is a unique identifier for each build step. + * @type {string} + * @memberof OSV1StepInfo + */ + name?: string; + /** + * + * @type {string} + * @memberof OSV1StepInfo + */ + startTime?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SubjectAccessReview.ts b/frontend/packages/kube-types/src/openshift/OSV1SubjectAccessReview.ts new file mode 100644 index 00000000000..54792957f47 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SubjectAccessReview.ts @@ -0,0 +1,106 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { IoK8sApimachineryPkgRuntimeRawExtension } from './IoK8sApimachineryPkgRuntimeRawExtension'; + +/** + * SubjectAccessReview is an object for requesting information about whether a user or group can perform an action + * @export + * @interface OSV1SubjectAccessReview + */ +export interface OSV1SubjectAccessReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1SubjectAccessReview + */ + apiVersion?: string; + /** + * + * @type {IoK8sApimachineryPkgRuntimeRawExtension} + * @memberof OSV1SubjectAccessReview + */ + content?: IoK8sApimachineryPkgRuntimeRawExtension; + /** + * GroupsSlice is optional. Groups is the list of groups to which the User belongs. + * @type {Array} + * @memberof OSV1SubjectAccessReview + */ + groups: string[]; + /** + * IsNonResourceURL is true if this is a request for a non-resource URL (outside of the resource hieraarchy) + * @type {boolean} + * @memberof OSV1SubjectAccessReview + */ + isNonResourceURL: boolean; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1SubjectAccessReview + */ + kind?: string; + /** + * Namespace is the namespace of the action being requested. Currently, there is no distinction between no namespace and all namespaces + * @type {string} + * @memberof OSV1SubjectAccessReview + */ + namespace: string; + /** + * Path is the path of a non resource URL + * @type {string} + * @memberof OSV1SubjectAccessReview + */ + path: string; + /** + * Resource is one of the existing resource types + * @type {string} + * @memberof OSV1SubjectAccessReview + */ + resource: string; + /** + * Group is the API group of the resource Serialized as resourceAPIGroup to avoid confusion with the \'groups\' field when inlined + * @type {string} + * @memberof OSV1SubjectAccessReview + */ + resourceAPIGroup: string; + /** + * Version is the API version of the resource Serialized as resourceAPIVersion to avoid confusion with TypeMeta.apiVersion and ObjectMeta.resourceVersion when inlined + * @type {string} + * @memberof OSV1SubjectAccessReview + */ + resourceAPIVersion: string; + /** + * ResourceName is the name of the resource being requested for a \"get\" or deleted for a \"delete\" + * @type {string} + * @memberof OSV1SubjectAccessReview + */ + resourceName: string; + /** + * Scopes to use for the evaluation. Empty means \"use the unscoped (full) permissions of the user/groups\". Nil for a self-SAR, means \"use the scopes on this request\". Nil for a regular SAR, means the same as empty. + * @type {Array} + * @memberof OSV1SubjectAccessReview + */ + scopes: string[]; + /** + * User is optional. If both User and Groups are empty, the current authenticated user is used. + * @type {string} + * @memberof OSV1SubjectAccessReview + */ + user: string; + /** + * Verb is one of: get, list, watch, create, update, delete + * @type {string} + * @memberof OSV1SubjectAccessReview + */ + verb: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReview.ts b/frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReview.ts new file mode 100644 index 00000000000..f1dac0779d1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReview.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1SubjectRulesReviewSpec } from './OSV1SubjectRulesReviewSpec'; +import { OSV1SubjectRulesReviewStatus } from './OSV1SubjectRulesReviewStatus'; + +/** + * SubjectRulesReview is a resource you can create to determine which actions another user can perform in a namespace + * @export + * @interface OSV1SubjectRulesReview + */ +export interface OSV1SubjectRulesReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1SubjectRulesReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1SubjectRulesReview + */ + kind?: string; + /** + * + * @type {OSV1SubjectRulesReviewSpec} + * @memberof OSV1SubjectRulesReview + */ + spec: OSV1SubjectRulesReviewSpec; + /** + * + * @type {OSV1SubjectRulesReviewStatus} + * @memberof OSV1SubjectRulesReview + */ + status?: OSV1SubjectRulesReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReviewSpec.ts b/frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReviewSpec.ts new file mode 100644 index 00000000000..912956623a8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReviewSpec.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SubjectRulesReviewSpec adds information about how to conduct the check + * @export + * @interface OSV1SubjectRulesReviewSpec + */ +export interface OSV1SubjectRulesReviewSpec { + /** + * Groups is optional. Groups is the list of groups to which the User belongs. At least one of User and Groups must be specified. + * @type {Array} + * @memberof OSV1SubjectRulesReviewSpec + */ + groups: string[]; + /** + * Scopes to use for the evaluation. Empty means \"use the unscoped (full) permissions of the user/groups\". + * @type {Array} + * @memberof OSV1SubjectRulesReviewSpec + */ + scopes: string[]; + /** + * User is optional. At least one of User and Groups must be specified. + * @type {string} + * @memberof OSV1SubjectRulesReviewSpec + */ + user: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReviewStatus.ts b/frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReviewStatus.ts new file mode 100644 index 00000000000..bcbf7755676 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SubjectRulesReviewStatus.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1PolicyRule } from './OSV1PolicyRule'; + +/** + * SubjectRulesReviewStatus is contains the result of a rules check + * @export + * @interface OSV1SubjectRulesReviewStatus + */ +export interface OSV1SubjectRulesReviewStatus { + /** + * EvaluationError can appear in combination with Rules. It means some error happened during evaluation that may have prevented additional rules from being populated. + * @type {string} + * @memberof OSV1SubjectRulesReviewStatus + */ + evaluationError?: string; + /** + * Rules is the list of rules (no particular sort) that are allowed for the subject + * @type {Array} + * @memberof OSV1SubjectRulesReviewStatus + */ + rules: OSV1PolicyRule[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1SupplementalGroupsStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/OSV1SupplementalGroupsStrategyOptions.ts new file mode 100644 index 00000000000..9ab89056249 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1SupplementalGroupsStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1IDRange } from './OSV1IDRange'; + +/** + * SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy. + * @export + * @interface OSV1SupplementalGroupsStrategyOptions + */ +export interface OSV1SupplementalGroupsStrategyOptions { + /** + * Ranges are the allowed ranges of supplemental groups. If you would like to force a single supplemental group then supply a single range with the same start and end. + * @type {Array} + * @memberof OSV1SupplementalGroupsStrategyOptions + */ + ranges?: OSV1IDRange[]; + /** + * Type is the strategy that will dictate what supplemental groups is used in the SecurityContext. + * @type {string} + * @memberof OSV1SupplementalGroupsStrategyOptions + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1TagEvent.ts b/frontend/packages/kube-types/src/openshift/OSV1TagEvent.ts new file mode 100644 index 00000000000..b259923e27d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1TagEvent.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TagEvent is used by ImageStreamStatus to keep a historical record of images associated with a tag. + * @export + * @interface OSV1TagEvent + */ +export interface OSV1TagEvent { + /** + * + * @type {string} + * @memberof OSV1TagEvent + */ + created: string; + /** + * DockerImageReference is the string that can be used to pull this image + * @type {string} + * @memberof OSV1TagEvent + */ + dockerImageReference: string; + /** + * Generation is the spec tag generation that resulted in this tag being updated + * @type {number} + * @memberof OSV1TagEvent + */ + generation: number; + /** + * Image is the image + * @type {string} + * @memberof OSV1TagEvent + */ + image: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1TagEventCondition.ts b/frontend/packages/kube-types/src/openshift/OSV1TagEventCondition.ts new file mode 100644 index 00000000000..d9cb8938ccf --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1TagEventCondition.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TagEventCondition contains condition information for a tag event. + * @export + * @interface OSV1TagEventCondition + */ +export interface OSV1TagEventCondition { + /** + * Generation is the spec tag generation that this status corresponds to + * @type {number} + * @memberof OSV1TagEventCondition + */ + generation: number; + /** + * + * @type {string} + * @memberof OSV1TagEventCondition + */ + lastTransitionTime?: string; + /** + * Message is a human readable description of the details about last transition, complementing reason. + * @type {string} + * @memberof OSV1TagEventCondition + */ + message?: string; + /** + * Reason is a brief machine readable explanation for the condition\'s last transition. + * @type {string} + * @memberof OSV1TagEventCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof OSV1TagEventCondition + */ + status: string; + /** + * Type of tag event condition, currently only ImportSuccess + * @type {string} + * @memberof OSV1TagEventCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1TagImageHook.ts b/frontend/packages/kube-types/src/openshift/OSV1TagImageHook.ts new file mode 100644 index 00000000000..8ba6b8c70cb --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1TagImageHook.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * TagImageHook is a request to tag the image in a particular container onto an ImageStreamTag. + * @export + * @interface OSV1TagImageHook + */ +export interface OSV1TagImageHook { + /** + * ContainerName is the name of a container in the deployment config whose image value will be used as the source of the tag. If there is only a single container this value will be defaulted to the name of that container. + * @type {string} + * @memberof OSV1TagImageHook + */ + containerName: string; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1TagImageHook + */ + to: V1ObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1TagImportPolicy.ts b/frontend/packages/kube-types/src/openshift/OSV1TagImportPolicy.ts new file mode 100644 index 00000000000..0768fd057b9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1TagImportPolicy.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TagImportPolicy controls how images related to this tag will be imported. + * @export + * @interface OSV1TagImportPolicy + */ +export interface OSV1TagImportPolicy { + /** + * Insecure is true if the server may bypass certificate verification or connect directly over HTTP during image import. + * @type {boolean} + * @memberof OSV1TagImportPolicy + */ + insecure?: boolean; + /** + * Scheduled indicates to the server that this tag should be periodically checked to ensure it is up to date, and imported + * @type {boolean} + * @memberof OSV1TagImportPolicy + */ + scheduled?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1TagReference.ts b/frontend/packages/kube-types/src/openshift/OSV1TagReference.ts new file mode 100644 index 00000000000..60a4a5e7a33 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1TagReference.ts @@ -0,0 +1,66 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1TagImportPolicy } from './OSV1TagImportPolicy'; +import { OSV1TagReferencePolicy } from './OSV1TagReferencePolicy'; +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * TagReference specifies optional annotations for images using this tag and an optional reference to an ImageStreamTag, ImageStreamImage, or DockerImage this tag should track. + * @export + * @interface OSV1TagReference + */ +export interface OSV1TagReference { + /** + * Optional; if specified, annotations that are applied to images retrieved via ImageStreamTags. + * @type {{ [key: string]: string; }} + * @memberof OSV1TagReference + */ + annotations?: { [key: string]: string }; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1TagReference + */ + from?: V1ObjectReference; + /** + * Generation is a counter that tracks mutations to the spec tag (user intent). When a tag reference is changed the generation is set to match the current stream generation (which is incremented every time spec is changed). Other processes in the system like the image importer observe that the generation of spec tag is newer than the generation recorded in the status and use that as a trigger to import the newest remote tag. To trigger a new import, clients may set this value to zero which will reset the generation to the latest stream generation. Legacy clients will send this value as nil which will be merged with the current tag generation. + * @type {number} + * @memberof OSV1TagReference + */ + generation?: number; + /** + * + * @type {OSV1TagImportPolicy} + * @memberof OSV1TagReference + */ + importPolicy?: OSV1TagImportPolicy; + /** + * Name of the tag + * @type {string} + * @memberof OSV1TagReference + */ + name: string; + /** + * Reference states if the tag will be imported. Default value is false, which means the tag will be imported. + * @type {boolean} + * @memberof OSV1TagReference + */ + reference?: boolean; + /** + * + * @type {OSV1TagReferencePolicy} + * @memberof OSV1TagReference + */ + referencePolicy?: OSV1TagReferencePolicy; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1TagReferencePolicy.ts b/frontend/packages/kube-types/src/openshift/OSV1TagReferencePolicy.ts new file mode 100644 index 00000000000..10e98399bd3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1TagReferencePolicy.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TagReferencePolicy describes how pull-specs for images in this image stream tag are generated when image change triggers in deployment configs or builds are resolved. This allows the image stream author to control how images are accessed. + * @export + * @interface OSV1TagReferencePolicy + */ +export interface OSV1TagReferencePolicy { + /** + * Type determines how the image pull spec should be transformed when the image stream tag is used in deployment config triggers or new builds. The default value is `Source`, indicating the original location of the image should be used (if imported). The user may also specify `Local`, indicating that the pull spec should point to the integrated container image registry and leverage the registry\'s ability to proxy the pull to an upstream registry. `Local` allows the credentials used to pull this image to be managed from the image stream\'s namespace, so others on the platform can access a remote image but have no access to the remote secret. It also allows the image layers to be mirrored into the local registry which the images can still be pulled even if the upstream registry is unavailable. + * @type {string} + * @memberof OSV1TagReferencePolicy + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1User.ts b/frontend/packages/kube-types/src/openshift/OSV1User.ts new file mode 100644 index 00000000000..bdc1fe49c23 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1User.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Upon log in, every user of the system receives a User and Identity resource. Administrators may directly manipulate the attributes of the users for their own tracking, or set groups via the API. The user name is unique and is chosen based on the value provided by the identity provider - if a user already exists with the incoming name, the user name may have a number appended to it depending on the configuration of the system. + * @export + * @interface OSV1User + */ +export interface OSV1User { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1User + */ + apiVersion?: string; + /** + * FullName is the full name of user + * @type {string} + * @memberof OSV1User + */ + fullName?: string; + /** + * Groups specifies group names this user is a member of. This field is deprecated and will be removed in a future release. Instead, create a Group object containing the name of this User. + * @type {Array} + * @memberof OSV1User + */ + groups: string[]; + /** + * Identities are the identities associated with this user + * @type {Array} + * @memberof OSV1User + */ + identities: string[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1User + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1User + */ + metadata?: V1ObjectMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1UserIdentityMapping.ts b/frontend/packages/kube-types/src/openshift/OSV1UserIdentityMapping.ts new file mode 100644 index 00000000000..60cfc1ef91f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1UserIdentityMapping.ts @@ -0,0 +1,53 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * UserIdentityMapping maps a user to an identity + * @export + * @interface OSV1UserIdentityMapping + */ +export interface OSV1UserIdentityMapping { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1UserIdentityMapping + */ + apiVersion?: string; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1UserIdentityMapping + */ + identity?: V1ObjectReference; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1UserIdentityMapping + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof OSV1UserIdentityMapping + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1ObjectReference} + * @memberof OSV1UserIdentityMapping + */ + user?: V1ObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1UserList.ts b/frontend/packages/kube-types/src/openshift/OSV1UserList.ts new file mode 100644 index 00000000000..42742b1ceb1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1UserList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1User } from './OSV1User'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * UserList is a collection of Users + * @export + * @interface OSV1UserList + */ +export interface OSV1UserList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof OSV1UserList + */ + apiVersion?: string; + /** + * Items is the list of users + * @type {Array} + * @memberof OSV1UserList + */ + items: OSV1User[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof OSV1UserList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof OSV1UserList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1UserRestriction.ts b/frontend/packages/kube-types/src/openshift/OSV1UserRestriction.ts new file mode 100644 index 00000000000..10bfad0c580 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1UserRestriction.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * UserRestriction matches a user either by a string match on the user name, a string match on the name of a group to which the user belongs, or a label selector applied to the user labels. + * @export + * @interface OSV1UserRestriction + */ +export interface OSV1UserRestriction { + /** + * Groups specifies a list of literal group names. + * @type {Array} + * @memberof OSV1UserRestriction + */ + groups: string[]; + /** + * Selectors specifies a list of label selectors over user labels. + * @type {Array} + * @memberof OSV1UserRestriction + */ + labels: V1LabelSelector[]; + /** + * Users specifies a list of literal user names. + * @type {Array} + * @memberof OSV1UserRestriction + */ + users: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/OSV1WebHookTrigger.ts b/frontend/packages/kube-types/src/openshift/OSV1WebHookTrigger.ts new file mode 100644 index 00000000000..37e490d0e12 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/OSV1WebHookTrigger.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { OSV1SecretLocalReference } from './OSV1SecretLocalReference'; + +/** + * WebHookTrigger is a trigger that gets invoked using a webhook type of post + * @export + * @interface OSV1WebHookTrigger + */ +export interface OSV1WebHookTrigger { + /** + * allowEnv determines whether the webhook can set environment variables; can only be set to true for GenericWebHook. + * @type {boolean} + * @memberof OSV1WebHookTrigger + */ + allowEnv?: boolean; + /** + * secret used to validate requests. Deprecated: use SecretReference instead. + * @type {string} + * @memberof OSV1WebHookTrigger + */ + secret?: string; + /** + * + * @type {OSV1SecretLocalReference} + * @memberof OSV1WebHookTrigger + */ + secretReference?: OSV1SecretLocalReference; +} diff --git a/frontend/packages/kube-types/src/openshift/V1APIGroup.ts b/frontend/packages/kube-types/src/openshift/V1APIGroup.ts new file mode 100644 index 00000000000..84bc48c2ff9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1APIGroup.ts @@ -0,0 +1,59 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1GroupVersionForDiscovery } from './V1GroupVersionForDiscovery'; +import { V1ServerAddressByClientCIDR } from './V1ServerAddressByClientCIDR'; + +/** + * APIGroup contains the name, the supported versions, and the preferred version of a group. + * @export + * @interface V1APIGroup + */ +export interface V1APIGroup { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1APIGroup + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1APIGroup + */ + kind?: string; + /** + * name is the name of the group. + * @type {string} + * @memberof V1APIGroup + */ + name: string; + /** + * + * @type {V1GroupVersionForDiscovery} + * @memberof V1APIGroup + */ + preferredVersion?: V1GroupVersionForDiscovery; + /** + * a map of client CIDR to server address that is serving this group. This is to help clients reach servers in the most network-efficient way possible. Clients can use the appropriate server address as per the CIDR that they match. In case of multiple matches, clients should use the longest matching CIDR. The server returns only those CIDRs that it thinks that the client can match. For example: the master will return an internal IP CIDR only, if the client reaches the server using an internal IP. Server looks at X-Forwarded-For header or X-Real-Ip header or request.RemoteAddr (in that order) to get the client IP. + * @type {Array} + * @memberof V1APIGroup + */ + serverAddressByClientCIDRs?: V1ServerAddressByClientCIDR[]; + /** + * versions are the versions supported in this group. + * @type {Array} + * @memberof V1APIGroup + */ + versions: V1GroupVersionForDiscovery[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1APIGroupList.ts b/frontend/packages/kube-types/src/openshift/V1APIGroupList.ts new file mode 100644 index 00000000000..51db07a123e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1APIGroupList.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1APIGroup } from './V1APIGroup'; + +/** + * APIGroupList is a list of APIGroup, to allow clients to discover the API at /apis. + * @export + * @interface V1APIGroupList + */ +export interface V1APIGroupList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1APIGroupList + */ + apiVersion?: string; + /** + * groups is a list of APIGroup. + * @type {Array} + * @memberof V1APIGroupList + */ + groups: V1APIGroup[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1APIGroupList + */ + kind?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1APIResource.ts b/frontend/packages/kube-types/src/openshift/V1APIResource.ts new file mode 100644 index 00000000000..8c6532d6303 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1APIResource.ts @@ -0,0 +1,74 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * APIResource specifies the name of a resource and whether it is namespaced. + * @export + * @interface V1APIResource + */ +export interface V1APIResource { + /** + * categories is a list of the grouped resources this resource belongs to (e.g. \'all\') + * @type {Array} + * @memberof V1APIResource + */ + categories?: string[]; + /** + * group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\". + * @type {string} + * @memberof V1APIResource + */ + group?: string; + /** + * kind is the kind for the resource (e.g. \'Foo\' is the kind for a resource \'foo\') + * @type {string} + * @memberof V1APIResource + */ + kind: string; + /** + * name is the plural name of the resource. + * @type {string} + * @memberof V1APIResource + */ + name: string; + /** + * namespaced indicates if a resource is namespaced or not. + * @type {boolean} + * @memberof V1APIResource + */ + namespaced: boolean; + /** + * shortNames is a list of suggested short names of the resource. + * @type {Array} + * @memberof V1APIResource + */ + shortNames?: string[]; + /** + * singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface. + * @type {string} + * @memberof V1APIResource + */ + singularName: string; + /** + * verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy) + * @type {Array} + * @memberof V1APIResource + */ + verbs: string[]; + /** + * version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource\'s group)\". + * @type {string} + * @memberof V1APIResource + */ + version?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1APIResourceList.ts b/frontend/packages/kube-types/src/openshift/V1APIResourceList.ts new file mode 100644 index 00000000000..9de2a74eca9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1APIResourceList.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1APIResource } from './V1APIResource'; + +/** + * APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced. + * @export + * @interface V1APIResourceList + */ +export interface V1APIResourceList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1APIResourceList + */ + apiVersion?: string; + /** + * groupVersion is the group and version this APIResourceList is for. + * @type {string} + * @memberof V1APIResourceList + */ + groupVersion: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1APIResourceList + */ + kind?: string; + /** + * resources contains the name of the resources and if they are namespaced. + * @type {Array} + * @memberof V1APIResourceList + */ + resources: V1APIResource[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1APIVersions.ts b/frontend/packages/kube-types/src/openshift/V1APIVersions.ts new file mode 100644 index 00000000000..a49eac5f00a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1APIVersions.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ServerAddressByClientCIDR } from './V1ServerAddressByClientCIDR'; + +/** + * APIVersions lists the versions that are available, to allow clients to discover the API at /api, which is the root path of the legacy v1 API. + * @export + * @interface V1APIVersions + */ +export interface V1APIVersions { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1APIVersions + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1APIVersions + */ + kind?: string; + /** + * a map of client CIDR to server address that is serving this group. This is to help clients reach servers in the most network-efficient way possible. Clients can use the appropriate server address as per the CIDR that they match. In case of multiple matches, clients should use the longest matching CIDR. The server returns only those CIDRs that it thinks that the client can match. For example: the master will return an internal IP CIDR only, if the client reaches the server using an internal IP. Server looks at X-Forwarded-For header or X-Real-Ip header or request.RemoteAddr (in that order) to get the client IP. + * @type {Array} + * @memberof V1APIVersions + */ + serverAddressByClientCIDRs: V1ServerAddressByClientCIDR[]; + /** + * versions are the api versions that are available. + * @type {Array} + * @memberof V1APIVersions + */ + versions: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1AWSElasticBlockStoreVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1AWSElasticBlockStoreVolumeSource.ts new file mode 100644 index 00000000000..a86d93810e4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1AWSElasticBlockStoreVolumeSource.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a Persistent Disk resource in AWS. An AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling. + * @export + * @interface V1AWSElasticBlockStoreVolumeSource + */ +export interface V1AWSElasticBlockStoreVolumeSource { + /** + * Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore + * @type {string} + * @memberof V1AWSElasticBlockStoreVolumeSource + */ + fsType?: string; + /** + * The partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). + * @type {number} + * @memberof V1AWSElasticBlockStoreVolumeSource + */ + partition?: number; + /** + * Specify \"true\" to force and set the ReadOnly property in VolumeMounts to \"true\". If omitted, the default is \"false\". More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore + * @type {boolean} + * @memberof V1AWSElasticBlockStoreVolumeSource + */ + readOnly?: boolean; + /** + * Unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore + * @type {string} + * @memberof V1AWSElasticBlockStoreVolumeSource + */ + volumeID: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Affinity.ts b/frontend/packages/kube-types/src/openshift/V1Affinity.ts new file mode 100644 index 00000000000..aab5d8de12b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Affinity.ts @@ -0,0 +1,42 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeAffinity } from './V1NodeAffinity'; +import { V1PodAffinity } from './V1PodAffinity'; +import { V1PodAntiAffinity } from './V1PodAntiAffinity'; + +/** + * Affinity is a group of affinity scheduling rules. + * @export + * @interface V1Affinity + */ +export interface V1Affinity { + /** + * + * @type {V1NodeAffinity} + * @memberof V1Affinity + */ + nodeAffinity?: V1NodeAffinity; + /** + * + * @type {V1PodAffinity} + * @memberof V1Affinity + */ + podAffinity?: V1PodAffinity; + /** + * + * @type {V1PodAntiAffinity} + * @memberof V1Affinity + */ + podAntiAffinity?: V1PodAntiAffinity; +} diff --git a/frontend/packages/kube-types/src/openshift/V1AggregationRule.ts b/frontend/packages/kube-types/src/openshift/V1AggregationRule.ts new file mode 100644 index 00000000000..1b7f25cb7de --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1AggregationRule.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole + * @export + * @interface V1AggregationRule + */ +export interface V1AggregationRule { + /** + * ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole\'s permissions will be added + * @type {Array} + * @memberof V1AggregationRule + */ + clusterRoleSelectors?: V1LabelSelector[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1AttachedVolume.ts b/frontend/packages/kube-types/src/openshift/V1AttachedVolume.ts new file mode 100644 index 00000000000..b347668e964 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1AttachedVolume.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * AttachedVolume describes a volume attached to a node + * @export + * @interface V1AttachedVolume + */ +export interface V1AttachedVolume { + /** + * DevicePath represents the device path where the volume should be available + * @type {string} + * @memberof V1AttachedVolume + */ + devicePath: string; + /** + * Name of the attached volume + * @type {string} + * @memberof V1AttachedVolume + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1AzureDiskVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1AzureDiskVolumeSource.ts new file mode 100644 index 00000000000..bc732ffbf3b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1AzureDiskVolumeSource.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod. + * @export + * @interface V1AzureDiskVolumeSource + */ +export interface V1AzureDiskVolumeSource { + /** + * Host Caching mode: None, Read Only, Read Write. + * @type {string} + * @memberof V1AzureDiskVolumeSource + */ + cachingMode?: string; + /** + * The Name of the data disk in the blob storage + * @type {string} + * @memberof V1AzureDiskVolumeSource + */ + diskName: string; + /** + * The URI the data disk in the blob storage + * @type {string} + * @memberof V1AzureDiskVolumeSource + */ + diskURI: string; + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. + * @type {string} + * @memberof V1AzureDiskVolumeSource + */ + fsType?: string; + /** + * Expected values Shared: multiple blob disks per storage account Dedicated: single blob disk per storage account Managed: azure managed data disk (only in managed availability set). defaults to shared + * @type {string} + * @memberof V1AzureDiskVolumeSource + */ + kind?: string; + /** + * Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. + * @type {boolean} + * @memberof V1AzureDiskVolumeSource + */ + readOnly?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1AzureFilePersistentVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1AzureFilePersistentVolumeSource.ts new file mode 100644 index 00000000000..47d729ecb4d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1AzureFilePersistentVolumeSource.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * AzureFile represents an Azure File Service mount on the host and bind mount to the pod. + * @export + * @interface V1AzureFilePersistentVolumeSource + */ +export interface V1AzureFilePersistentVolumeSource { + /** + * Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. + * @type {boolean} + * @memberof V1AzureFilePersistentVolumeSource + */ + readOnly?: boolean; + /** + * the name of secret that contains Azure Storage Account Name and Key + * @type {string} + * @memberof V1AzureFilePersistentVolumeSource + */ + secretName: string; + /** + * the namespace of the secret that contains Azure Storage Account Name and Key default is the same as the Pod + * @type {string} + * @memberof V1AzureFilePersistentVolumeSource + */ + secretNamespace?: string; + /** + * Share Name + * @type {string} + * @memberof V1AzureFilePersistentVolumeSource + */ + shareName: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1AzureFileVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1AzureFileVolumeSource.ts new file mode 100644 index 00000000000..abc7991a16d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1AzureFileVolumeSource.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * AzureFile represents an Azure File Service mount on the host and bind mount to the pod. + * @export + * @interface V1AzureFileVolumeSource + */ +export interface V1AzureFileVolumeSource { + /** + * Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. + * @type {boolean} + * @memberof V1AzureFileVolumeSource + */ + readOnly?: boolean; + /** + * the name of secret that contains Azure Storage Account Name and Key + * @type {string} + * @memberof V1AzureFileVolumeSource + */ + secretName: string; + /** + * Share Name + * @type {string} + * @memberof V1AzureFileVolumeSource + */ + shareName: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Binding.ts b/frontend/packages/kube-types/src/openshift/V1Binding.ts new file mode 100644 index 00000000000..e90dcc82ba5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Binding.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Binding ties one object to another; for example, a pod is bound to a node by a scheduler. Deprecated in 1.7, please use the bindings subresource of pods instead. + * @export + * @interface V1Binding + */ +export interface V1Binding { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Binding + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Binding + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Binding + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1ObjectReference} + * @memberof V1Binding + */ + target: V1ObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstance.ts b/frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstance.ts new file mode 100644 index 00000000000..72c2c889ee7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstance.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1BrokerTemplateInstanceSpec } from './V1BrokerTemplateInstanceSpec'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * BrokerTemplateInstance holds the service broker-related state associated with a TemplateInstance. BrokerTemplateInstance is part of an experimental API. + * @export + * @interface V1BrokerTemplateInstance + */ +export interface V1BrokerTemplateInstance { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1BrokerTemplateInstance + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1BrokerTemplateInstance + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1BrokerTemplateInstance + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1BrokerTemplateInstanceSpec} + * @memberof V1BrokerTemplateInstance + */ + spec: V1BrokerTemplateInstanceSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstanceList.ts b/frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstanceList.ts new file mode 100644 index 00000000000..0246625186c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstanceList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1BrokerTemplateInstance } from './V1BrokerTemplateInstance'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * BrokerTemplateInstanceList is a list of BrokerTemplateInstance objects. + * @export + * @interface V1BrokerTemplateInstanceList + */ +export interface V1BrokerTemplateInstanceList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1BrokerTemplateInstanceList + */ + apiVersion?: string; + /** + * items is a list of BrokerTemplateInstances + * @type {Array} + * @memberof V1BrokerTemplateInstanceList + */ + items: V1BrokerTemplateInstance[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1BrokerTemplateInstanceList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1BrokerTemplateInstanceList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstanceSpec.ts b/frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstanceSpec.ts new file mode 100644 index 00000000000..f439d6f9883 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1BrokerTemplateInstanceSpec.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * BrokerTemplateInstanceSpec describes the state of a BrokerTemplateInstance. + * @export + * @interface V1BrokerTemplateInstanceSpec + */ +export interface V1BrokerTemplateInstanceSpec { + /** + * bindingids is a list of \'binding_id\'s provided during successive bind calls to the template service broker. + * @type {Array} + * @memberof V1BrokerTemplateInstanceSpec + */ + bindingIDs?: string[]; + /** + * + * @type {V1ObjectReference} + * @memberof V1BrokerTemplateInstanceSpec + */ + secret: V1ObjectReference; + /** + * + * @type {V1ObjectReference} + * @memberof V1BrokerTemplateInstanceSpec + */ + templateInstance: V1ObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/V1CSIPersistentVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1CSIPersistentVolumeSource.ts new file mode 100644 index 00000000000..19d726506b1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1CSIPersistentVolumeSource.ts @@ -0,0 +1,70 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SecretReference } from './V1SecretReference'; + +/** + * Represents storage that is managed by an external CSI volume driver (Beta feature) + * @export + * @interface V1CSIPersistentVolumeSource + */ +export interface V1CSIPersistentVolumeSource { + /** + * + * @type {V1SecretReference} + * @memberof V1CSIPersistentVolumeSource + */ + controllerPublishSecretRef?: V1SecretReference; + /** + * Driver is the name of the driver to use for this volume. Required. + * @type {string} + * @memberof V1CSIPersistentVolumeSource + */ + driver: string; + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". + * @type {string} + * @memberof V1CSIPersistentVolumeSource + */ + fsType?: string; + /** + * + * @type {V1SecretReference} + * @memberof V1CSIPersistentVolumeSource + */ + nodePublishSecretRef?: V1SecretReference; + /** + * + * @type {V1SecretReference} + * @memberof V1CSIPersistentVolumeSource + */ + nodeStageSecretRef?: V1SecretReference; + /** + * Optional: The value to pass to ControllerPublishVolumeRequest. Defaults to false (read/write). + * @type {boolean} + * @memberof V1CSIPersistentVolumeSource + */ + readOnly?: boolean; + /** + * Attributes of the volume to publish. + * @type {{ [key: string]: string; }} + * @memberof V1CSIPersistentVolumeSource + */ + volumeAttributes?: { [key: string]: string }; + /** + * VolumeHandle is the unique volume name returned by the CSI volume plugin’s CreateVolume to refer to the volume on all subsequent calls. Required. + * @type {string} + * @memberof V1CSIPersistentVolumeSource + */ + volumeHandle: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Capabilities.ts b/frontend/packages/kube-types/src/openshift/V1Capabilities.ts new file mode 100644 index 00000000000..7e331683a51 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Capabilities.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Adds and removes POSIX capabilities from running containers. + * @export + * @interface V1Capabilities + */ +export interface V1Capabilities { + /** + * Added capabilities + * @type {Array} + * @memberof V1Capabilities + */ + add?: string[]; + /** + * Removed capabilities + * @type {Array} + * @memberof V1Capabilities + */ + drop?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1CephFSPersistentVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1CephFSPersistentVolumeSource.ts new file mode 100644 index 00000000000..7ea5e79ba0e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1CephFSPersistentVolumeSource.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SecretReference } from './V1SecretReference'; + +/** + * Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling. + * @export + * @interface V1CephFSPersistentVolumeSource + */ +export interface V1CephFSPersistentVolumeSource { + /** + * Required: Monitors is a collection of Ceph monitors More info: https://releases.k8s.io/HEAD/examples/volumes/cephfs/README.md#how-to-use-it + * @type {Array} + * @memberof V1CephFSPersistentVolumeSource + */ + monitors: string[]; + /** + * Optional: Used as the mounted root, rather than the full Ceph tree, default is / + * @type {string} + * @memberof V1CephFSPersistentVolumeSource + */ + path?: string; + /** + * Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://releases.k8s.io/HEAD/examples/volumes/cephfs/README.md#how-to-use-it + * @type {boolean} + * @memberof V1CephFSPersistentVolumeSource + */ + readOnly?: boolean; + /** + * Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://releases.k8s.io/HEAD/examples/volumes/cephfs/README.md#how-to-use-it + * @type {string} + * @memberof V1CephFSPersistentVolumeSource + */ + secretFile?: string; + /** + * + * @type {V1SecretReference} + * @memberof V1CephFSPersistentVolumeSource + */ + secretRef?: V1SecretReference; + /** + * Optional: User is the rados user name, default is admin More info: https://releases.k8s.io/HEAD/examples/volumes/cephfs/README.md#how-to-use-it + * @type {string} + * @memberof V1CephFSPersistentVolumeSource + */ + user?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1CephFSVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1CephFSVolumeSource.ts new file mode 100644 index 00000000000..09cbd1003ba --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1CephFSVolumeSource.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling. + * @export + * @interface V1CephFSVolumeSource + */ +export interface V1CephFSVolumeSource { + /** + * Required: Monitors is a collection of Ceph monitors More info: https://releases.k8s.io/HEAD/examples/volumes/cephfs/README.md#how-to-use-it + * @type {Array} + * @memberof V1CephFSVolumeSource + */ + monitors: string[]; + /** + * Optional: Used as the mounted root, rather than the full Ceph tree, default is / + * @type {string} + * @memberof V1CephFSVolumeSource + */ + path?: string; + /** + * Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://releases.k8s.io/HEAD/examples/volumes/cephfs/README.md#how-to-use-it + * @type {boolean} + * @memberof V1CephFSVolumeSource + */ + readOnly?: boolean; + /** + * Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://releases.k8s.io/HEAD/examples/volumes/cephfs/README.md#how-to-use-it + * @type {string} + * @memberof V1CephFSVolumeSource + */ + secretFile?: string; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1CephFSVolumeSource + */ + secretRef?: V1LocalObjectReference; + /** + * Optional: User is the rados user name, default is admin More info: https://releases.k8s.io/HEAD/examples/volumes/cephfs/README.md#how-to-use-it + * @type {string} + * @memberof V1CephFSVolumeSource + */ + user?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1CinderPersistentVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1CinderPersistentVolumeSource.ts new file mode 100644 index 00000000000..b7d0f4a262c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1CinderPersistentVolumeSource.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SecretReference } from './V1SecretReference'; + +/** + * Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling. + * @export + * @interface V1CinderPersistentVolumeSource + */ +export interface V1CinderPersistentVolumeSource { + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://releases.k8s.io/HEAD/examples/mysql-cinder-pd/README.md + * @type {string} + * @memberof V1CinderPersistentVolumeSource + */ + fsType?: string; + /** + * Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://releases.k8s.io/HEAD/examples/mysql-cinder-pd/README.md + * @type {boolean} + * @memberof V1CinderPersistentVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1SecretReference} + * @memberof V1CinderPersistentVolumeSource + */ + secretRef?: V1SecretReference; + /** + * volume id used to identify the volume in cinder More info: https://releases.k8s.io/HEAD/examples/mysql-cinder-pd/README.md + * @type {string} + * @memberof V1CinderPersistentVolumeSource + */ + volumeID: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1CinderVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1CinderVolumeSource.ts new file mode 100644 index 00000000000..09e2bb8d45d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1CinderVolumeSource.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling. + * @export + * @interface V1CinderVolumeSource + */ +export interface V1CinderVolumeSource { + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://releases.k8s.io/HEAD/examples/mysql-cinder-pd/README.md + * @type {string} + * @memberof V1CinderVolumeSource + */ + fsType?: string; + /** + * Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. More info: https://releases.k8s.io/HEAD/examples/mysql-cinder-pd/README.md + * @type {boolean} + * @memberof V1CinderVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1CinderVolumeSource + */ + secretRef?: V1LocalObjectReference; + /** + * volume id used to identify the volume in cinder More info: https://releases.k8s.io/HEAD/examples/mysql-cinder-pd/README.md + * @type {string} + * @memberof V1CinderVolumeSource + */ + volumeID: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ClientIPConfig.ts b/frontend/packages/kube-types/src/openshift/V1ClientIPConfig.ts new file mode 100644 index 00000000000..67b6ececa1f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ClientIPConfig.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ClientIPConfig represents the configurations of Client IP based session affinity. + * @export + * @interface V1ClientIPConfig + */ +export interface V1ClientIPConfig { + /** + * timeoutSeconds specifies the seconds of ClientIP type session sticky time. The value must be >0 && <=86400(for 1 day) if ServiceAffinity == \"ClientIP\". Default value is 10800(for 3 hours). + * @type {number} + * @memberof V1ClientIPConfig + */ + timeoutSeconds?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ClusterRole.ts b/frontend/packages/kube-types/src/openshift/V1ClusterRole.ts new file mode 100644 index 00000000000..79edd11cf53 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ClusterRole.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1AggregationRule } from './V1AggregationRule'; +import { V1PolicyRule } from './V1PolicyRule'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. + * @export + * @interface V1ClusterRole + */ +export interface V1ClusterRole { + /** + * + * @type {V1AggregationRule} + * @memberof V1ClusterRole + */ + aggregationRule?: V1AggregationRule; + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ClusterRole + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ClusterRole + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1ClusterRole + */ + metadata?: V1ObjectMeta; + /** + * Rules holds all the PolicyRules for this ClusterRole + * @type {Array} + * @memberof V1ClusterRole + */ + rules: V1PolicyRule[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ClusterRoleBinding.ts b/frontend/packages/kube-types/src/openshift/V1ClusterRoleBinding.ts new file mode 100644 index 00000000000..0d7e2c7e150 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ClusterRoleBinding.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1RoleRef } from './V1RoleRef'; +import { V1Subject } from './V1Subject'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. + * @export + * @interface V1ClusterRoleBinding + */ +export interface V1ClusterRoleBinding { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ClusterRoleBinding + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ClusterRoleBinding + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1ClusterRoleBinding + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1RoleRef} + * @memberof V1ClusterRoleBinding + */ + roleRef: V1RoleRef; + /** + * Subjects holds references to the objects the role applies to. + * @type {Array} + * @memberof V1ClusterRoleBinding + */ + subjects?: V1Subject[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ClusterRoleBindingList.ts b/frontend/packages/kube-types/src/openshift/V1ClusterRoleBindingList.ts new file mode 100644 index 00000000000..e30d453bec2 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ClusterRoleBindingList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ClusterRoleBinding } from './V1ClusterRoleBinding'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ClusterRoleBindingList is a collection of ClusterRoleBindings + * @export + * @interface V1ClusterRoleBindingList + */ +export interface V1ClusterRoleBindingList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ClusterRoleBindingList + */ + apiVersion?: string; + /** + * Items is a list of ClusterRoleBindings + * @type {Array} + * @memberof V1ClusterRoleBindingList + */ + items: V1ClusterRoleBinding[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ClusterRoleBindingList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1ClusterRoleBindingList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ClusterRoleList.ts b/frontend/packages/kube-types/src/openshift/V1ClusterRoleList.ts new file mode 100644 index 00000000000..83f977df3c1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ClusterRoleList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ClusterRole } from './V1ClusterRole'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ClusterRoleList is a collection of ClusterRoles + * @export + * @interface V1ClusterRoleList + */ +export interface V1ClusterRoleList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ClusterRoleList + */ + apiVersion?: string; + /** + * Items is a list of ClusterRoles + * @type {Array} + * @memberof V1ClusterRoleList + */ + items: V1ClusterRole[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ClusterRoleList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1ClusterRoleList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ComponentCondition.ts b/frontend/packages/kube-types/src/openshift/V1ComponentCondition.ts new file mode 100644 index 00000000000..cf7103aa1bf --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ComponentCondition.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Information about the condition of a component. + * @export + * @interface V1ComponentCondition + */ +export interface V1ComponentCondition { + /** + * Condition error code for a component. For example, a health check error code. + * @type {string} + * @memberof V1ComponentCondition + */ + error?: string; + /** + * Message about the condition for a component. For example, information about a health check. + * @type {string} + * @memberof V1ComponentCondition + */ + message?: string; + /** + * Status of the condition for a component. Valid values for \"Healthy\": \"True\", \"False\", or \"Unknown\". + * @type {string} + * @memberof V1ComponentCondition + */ + status: string; + /** + * Type of condition for a component. Valid value: \"Healthy\" + * @type {string} + * @memberof V1ComponentCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ComponentStatus.ts b/frontend/packages/kube-types/src/openshift/V1ComponentStatus.ts new file mode 100644 index 00000000000..ba41095bf72 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ComponentStatus.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ComponentCondition } from './V1ComponentCondition'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ComponentStatus (and ComponentStatusList) holds the cluster validation info. + * @export + * @interface V1ComponentStatus + */ +export interface V1ComponentStatus { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ComponentStatus + */ + apiVersion?: string; + /** + * List of component conditions observed + * @type {Array} + * @memberof V1ComponentStatus + */ + conditions?: V1ComponentCondition[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ComponentStatus + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1ComponentStatus + */ + metadata?: V1ObjectMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ComponentStatusList.ts b/frontend/packages/kube-types/src/openshift/V1ComponentStatusList.ts new file mode 100644 index 00000000000..315ead09b4d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ComponentStatusList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ComponentStatus } from './V1ComponentStatus'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * Status of all the conditions for the component as a list of ComponentStatus objects. + * @export + * @interface V1ComponentStatusList + */ +export interface V1ComponentStatusList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ComponentStatusList + */ + apiVersion?: string; + /** + * List of ComponentStatus objects. + * @type {Array} + * @memberof V1ComponentStatusList + */ + items: V1ComponentStatus[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ComponentStatusList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1ComponentStatusList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ConfigMap.ts b/frontend/packages/kube-types/src/openshift/V1ConfigMap.ts new file mode 100644 index 00000000000..01786a57cf8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ConfigMap.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ConfigMap holds configuration data for pods to consume. + * @export + * @interface V1ConfigMap + */ +export interface V1ConfigMap { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ConfigMap + */ + apiVersion?: string; + /** + * BinaryData contains the binary data. Each key must consist of alphanumeric characters, \'-\', \'_\' or \'.\'. BinaryData can contain byte sequences that are not in the UTF-8 range. The keys stored in BinaryData must not overlap with the ones in the Data field, this is enforced during validation process. Using this field will require 1.10+ apiserver and kubelet. + * @type {{ [key: string]: string; }} + * @memberof V1ConfigMap + */ + binaryData?: { [key: string]: string }; + /** + * Data contains the configuration data. Each key must consist of alphanumeric characters, \'-\', \'_\' or \'.\'. Values with non-UTF-8 byte sequences must use the BinaryData field. The keys stored in Data must not overlap with the keys in the BinaryData field, this is enforced during validation process. + * @type {{ [key: string]: string; }} + * @memberof V1ConfigMap + */ + data?: { [key: string]: string }; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ConfigMap + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1ConfigMap + */ + metadata?: V1ObjectMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ConfigMapEnvSource.ts b/frontend/packages/kube-types/src/openshift/V1ConfigMapEnvSource.ts new file mode 100644 index 00000000000..cd5eba791cb --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ConfigMapEnvSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ConfigMapEnvSource selects a ConfigMap to populate the environment variables with. The contents of the target ConfigMap\'s Data field will represent the key-value pairs as environment variables. + * @export + * @interface V1ConfigMapEnvSource + */ +export interface V1ConfigMapEnvSource { + /** + * Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1ConfigMapEnvSource + */ + name?: string; + /** + * Specify whether the ConfigMap must be defined + * @type {boolean} + * @memberof V1ConfigMapEnvSource + */ + optional?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ConfigMapKeySelector.ts b/frontend/packages/kube-types/src/openshift/V1ConfigMapKeySelector.ts new file mode 100644 index 00000000000..4892277d323 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ConfigMapKeySelector.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Selects a key from a ConfigMap. + * @export + * @interface V1ConfigMapKeySelector + */ +export interface V1ConfigMapKeySelector { + /** + * The key to select. + * @type {string} + * @memberof V1ConfigMapKeySelector + */ + key: string; + /** + * Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1ConfigMapKeySelector + */ + name?: string; + /** + * Specify whether the ConfigMap or it\'s key must be defined + * @type {boolean} + * @memberof V1ConfigMapKeySelector + */ + optional?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ConfigMapList.ts b/frontend/packages/kube-types/src/openshift/V1ConfigMapList.ts new file mode 100644 index 00000000000..98b868e123c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ConfigMapList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ConfigMap } from './V1ConfigMap'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ConfigMapList is a resource containing a list of ConfigMap objects. + * @export + * @interface V1ConfigMapList + */ +export interface V1ConfigMapList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ConfigMapList + */ + apiVersion?: string; + /** + * Items is the list of ConfigMaps. + * @type {Array} + * @memberof V1ConfigMapList + */ + items: V1ConfigMap[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ConfigMapList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1ConfigMapList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ConfigMapNodeConfigSource.ts b/frontend/packages/kube-types/src/openshift/V1ConfigMapNodeConfigSource.ts new file mode 100644 index 00000000000..2cae2f60799 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ConfigMapNodeConfigSource.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ConfigMapNodeConfigSource contains the information to reference a ConfigMap as a config source for the Node. + * @export + * @interface V1ConfigMapNodeConfigSource + */ +export interface V1ConfigMapNodeConfigSource { + /** + * KubeletConfigKey declares which key of the referenced ConfigMap corresponds to the KubeletConfiguration structure This field is required in all cases. + * @type {string} + * @memberof V1ConfigMapNodeConfigSource + */ + kubeletConfigKey: string; + /** + * Name is the metadata.name of the referenced ConfigMap. This field is required in all cases. + * @type {string} + * @memberof V1ConfigMapNodeConfigSource + */ + name: string; + /** + * Namespace is the metadata.namespace of the referenced ConfigMap. This field is required in all cases. + * @type {string} + * @memberof V1ConfigMapNodeConfigSource + */ + namespace: string; + /** + * ResourceVersion is the metadata.ResourceVersion of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status. + * @type {string} + * @memberof V1ConfigMapNodeConfigSource + */ + resourceVersion?: string; + /** + * UID is the metadata.UID of the referenced ConfigMap. This field is forbidden in Node.Spec, and required in Node.Status. + * @type {string} + * @memberof V1ConfigMapNodeConfigSource + */ + uid?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ConfigMapProjection.ts b/frontend/packages/kube-types/src/openshift/V1ConfigMapProjection.ts new file mode 100644 index 00000000000..c3b48649adf --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ConfigMapProjection.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1KeyToPath } from './V1KeyToPath'; + +/** + * Adapts a ConfigMap into a projected volume. The contents of the target ConfigMap\'s Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode. + * @export + * @interface V1ConfigMapProjection + */ +export interface V1ConfigMapProjection { + /** + * If unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the \'..\' path or start with \'..\'. + * @type {Array} + * @memberof V1ConfigMapProjection + */ + items?: V1KeyToPath[]; + /** + * Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1ConfigMapProjection + */ + name?: string; + /** + * Specify whether the ConfigMap or it\'s keys must be defined + * @type {boolean} + * @memberof V1ConfigMapProjection + */ + optional?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ConfigMapVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1ConfigMapVolumeSource.ts new file mode 100644 index 00000000000..82d7d9d3fa0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ConfigMapVolumeSource.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1KeyToPath } from './V1KeyToPath'; + +/** + * Adapts a ConfigMap into a volume. The contents of the target ConfigMap\'s Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling. + * @export + * @interface V1ConfigMapVolumeSource + */ +export interface V1ConfigMapVolumeSource { + /** + * Optional: mode bits to use on created files by default. Must be a value between 0 and 0777. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. + * @type {number} + * @memberof V1ConfigMapVolumeSource + */ + defaultMode?: number; + /** + * If unspecified, each key-value pair in the Data field of the referenced ConfigMap will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the ConfigMap, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the \'..\' path or start with \'..\'. + * @type {Array} + * @memberof V1ConfigMapVolumeSource + */ + items?: V1KeyToPath[]; + /** + * Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1ConfigMapVolumeSource + */ + name?: string; + /** + * Specify whether the ConfigMap or it\'s keys must be defined + * @type {boolean} + * @memberof V1ConfigMapVolumeSource + */ + optional?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Container.ts b/frontend/packages/kube-types/src/openshift/V1Container.ts new file mode 100644 index 00000000000..bfd1b6e9eaa --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Container.ts @@ -0,0 +1,156 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ContainerPort } from './V1ContainerPort'; +import { V1EnvFromSource } from './V1EnvFromSource'; +import { V1EnvVar } from './V1EnvVar'; +import { V1Lifecycle } from './V1Lifecycle'; +import { V1Probe } from './V1Probe'; +import { V1ResourceRequirements } from './V1ResourceRequirements'; +import { V1SecurityContext } from './V1SecurityContext'; +import { V1VolumeDevice } from './V1VolumeDevice'; +import { V1VolumeMount } from './V1VolumeMount'; + +/** + * A single application container that you want to run within a pod. + * @export + * @interface V1Container + */ +export interface V1Container { + /** + * Arguments to the entrypoint. The docker image\'s CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container\'s environment. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell + * @type {Array} + * @memberof V1Container + */ + args?: string[]; + /** + * Entrypoint array. Not executed within a shell. The docker image\'s ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container\'s environment. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell + * @type {Array} + * @memberof V1Container + */ + command?: string[]; + /** + * List of environment variables to set in the container. Cannot be updated. + * @type {Array} + * @memberof V1Container + */ + env?: V1EnvVar[]; + /** + * List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated. + * @type {Array} + * @memberof V1Container + */ + envFrom?: V1EnvFromSource[]; + /** + * Docker image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets. + * @type {string} + * @memberof V1Container + */ + image?: string; + /** + * Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images + * @type {string} + * @memberof V1Container + */ + imagePullPolicy?: string; + /** + * + * @type {V1Lifecycle} + * @memberof V1Container + */ + lifecycle?: V1Lifecycle; + /** + * + * @type {V1Probe} + * @memberof V1Container + */ + livenessProbe?: V1Probe; + /** + * Name of the container specified as a DNS_LABEL. Each container in a pod must have a unique name (DNS_LABEL). Cannot be updated. + * @type {string} + * @memberof V1Container + */ + name: string; + /** + * List of ports to expose from the container. Exposing a port here gives the system additional information about the network connections a container uses, but is primarily informational. Not specifying a port here DOES NOT prevent that port from being exposed. Any port which is listening on the default \"0.0.0.0\" address inside a container will be accessible from the network. Cannot be updated. + * @type {Array} + * @memberof V1Container + */ + ports?: V1ContainerPort[]; + /** + * + * @type {V1Probe} + * @memberof V1Container + */ + readinessProbe?: V1Probe; + /** + * + * @type {V1ResourceRequirements} + * @memberof V1Container + */ + resources?: V1ResourceRequirements; + /** + * + * @type {V1SecurityContext} + * @memberof V1Container + */ + securityContext?: V1SecurityContext; + /** + * Whether this container should allocate a buffer for stdin in the container runtime. If this is not set, reads from stdin in the container will always result in EOF. Default is false. + * @type {boolean} + * @memberof V1Container + */ + stdin?: boolean; + /** + * Whether the container runtime should close the stdin channel after it has been opened by a single attach. When stdin is true the stdin stream will remain open across multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start, is empty until the first client attaches to stdin, and then remains open and accepts data until the client disconnects, at which time stdin is closed and remains closed until the container is restarted. If this flag is false, a container processes that reads from stdin will never receive an EOF. Default is false + * @type {boolean} + * @memberof V1Container + */ + stdinOnce?: boolean; + /** + * Optional: Path at which the file to which the container\'s termination message will be written is mounted into the container\'s filesystem. Message written is intended to be brief final status, such as an assertion failure message. Will be truncated by the node if greater than 4096 bytes. The total message length across all containers will be limited to 12kb. Defaults to /dev/termination-log. Cannot be updated. + * @type {string} + * @memberof V1Container + */ + terminationMessagePath?: string; + /** + * Indicate how the termination message should be populated. File will use the contents of terminationMessagePath to populate the container status message on both success and failure. FallbackToLogsOnError will use the last chunk of container log output if the termination message file is empty and the container exited with an error. The log output is limited to 2048 bytes or 80 lines, whichever is smaller. Defaults to File. Cannot be updated. + * @type {string} + * @memberof V1Container + */ + terminationMessagePolicy?: string; + /** + * Whether this container should allocate a TTY for itself, also requires \'stdin\' to be true. Default is false. + * @type {boolean} + * @memberof V1Container + */ + tty?: boolean; + /** + * volumeDevices is the list of block devices to be used by the container. This is an alpha feature and may change in the future. + * @type {Array} + * @memberof V1Container + */ + volumeDevices?: V1VolumeDevice[]; + /** + * Pod volumes to mount into the container\'s filesystem. Cannot be updated. + * @type {Array} + * @memberof V1Container + */ + volumeMounts?: V1VolumeMount[]; + /** + * Container\'s working directory. If not specified, the container runtime\'s default will be used, which might be configured in the container image. Cannot be updated. + * @type {string} + * @memberof V1Container + */ + workingDir?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ContainerImage.ts b/frontend/packages/kube-types/src/openshift/V1ContainerImage.ts new file mode 100644 index 00000000000..9343435b2d7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ContainerImage.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Describe a container image + * @export + * @interface V1ContainerImage + */ +export interface V1ContainerImage { + /** + * Names by which this image is known. e.g. [\"k8s.gcr.io/hyperkube:v1.0.7\", \"dockerhub.io/google_containers/hyperkube:v1.0.7\"] + * @type {Array} + * @memberof V1ContainerImage + */ + names: string[]; + /** + * The size of the image in bytes. + * @type {number} + * @memberof V1ContainerImage + */ + sizeBytes?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ContainerPort.ts b/frontend/packages/kube-types/src/openshift/V1ContainerPort.ts new file mode 100644 index 00000000000..30de6e83859 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ContainerPort.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ContainerPort represents a network port in a single container. + * @export + * @interface V1ContainerPort + */ +export interface V1ContainerPort { + /** + * Number of port to expose on the pod\'s IP address. This must be a valid port number, 0 < x < 65536. + * @type {number} + * @memberof V1ContainerPort + */ + containerPort: number; + /** + * What host IP to bind the external port to. + * @type {string} + * @memberof V1ContainerPort + */ + hostIP?: string; + /** + * Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536. If HostNetwork is specified, this must match ContainerPort. Most containers do not need this. + * @type {number} + * @memberof V1ContainerPort + */ + hostPort?: number; + /** + * If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services. + * @type {string} + * @memberof V1ContainerPort + */ + name?: string; + /** + * Protocol for port. Must be UDP or TCP. Defaults to \"TCP\". + * @type {string} + * @memberof V1ContainerPort + */ + protocol?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ContainerState.ts b/frontend/packages/kube-types/src/openshift/V1ContainerState.ts new file mode 100644 index 00000000000..7b90fd275ec --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ContainerState.ts @@ -0,0 +1,42 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ContainerStateRunning } from './V1ContainerStateRunning'; +import { V1ContainerStateTerminated } from './V1ContainerStateTerminated'; +import { V1ContainerStateWaiting } from './V1ContainerStateWaiting'; + +/** + * ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting. + * @export + * @interface V1ContainerState + */ +export interface V1ContainerState { + /** + * + * @type {V1ContainerStateRunning} + * @memberof V1ContainerState + */ + running?: V1ContainerStateRunning; + /** + * + * @type {V1ContainerStateTerminated} + * @memberof V1ContainerState + */ + terminated?: V1ContainerStateTerminated; + /** + * + * @type {V1ContainerStateWaiting} + * @memberof V1ContainerState + */ + waiting?: V1ContainerStateWaiting; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ContainerStateRunning.ts b/frontend/packages/kube-types/src/openshift/V1ContainerStateRunning.ts new file mode 100644 index 00000000000..b2fbe431bfa --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ContainerStateRunning.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ContainerStateRunning is a running state of a container. + * @export + * @interface V1ContainerStateRunning + */ +export interface V1ContainerStateRunning { + /** + * + * @type {string} + * @memberof V1ContainerStateRunning + */ + startedAt?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ContainerStateTerminated.ts b/frontend/packages/kube-types/src/openshift/V1ContainerStateTerminated.ts new file mode 100644 index 00000000000..7776db4fd7f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ContainerStateTerminated.ts @@ -0,0 +1,62 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ContainerStateTerminated is a terminated state of a container. + * @export + * @interface V1ContainerStateTerminated + */ +export interface V1ContainerStateTerminated { + /** + * Container\'s ID in the format \'docker://\' + * @type {string} + * @memberof V1ContainerStateTerminated + */ + containerID?: string; + /** + * Exit status from the last termination of the container + * @type {number} + * @memberof V1ContainerStateTerminated + */ + exitCode: number; + /** + * + * @type {string} + * @memberof V1ContainerStateTerminated + */ + finishedAt?: string; + /** + * Message regarding the last termination of the container + * @type {string} + * @memberof V1ContainerStateTerminated + */ + message?: string; + /** + * (brief) reason from the last termination of the container + * @type {string} + * @memberof V1ContainerStateTerminated + */ + reason?: string; + /** + * Signal from the last termination of the container + * @type {number} + * @memberof V1ContainerStateTerminated + */ + signal?: number; + /** + * + * @type {string} + * @memberof V1ContainerStateTerminated + */ + startedAt?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ContainerStateWaiting.ts b/frontend/packages/kube-types/src/openshift/V1ContainerStateWaiting.ts new file mode 100644 index 00000000000..496d3f9a084 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ContainerStateWaiting.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ContainerStateWaiting is a waiting state of a container. + * @export + * @interface V1ContainerStateWaiting + */ +export interface V1ContainerStateWaiting { + /** + * Message regarding why the container is not yet running. + * @type {string} + * @memberof V1ContainerStateWaiting + */ + message?: string; + /** + * (brief) reason the container is not yet running. + * @type {string} + * @memberof V1ContainerStateWaiting + */ + reason?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ContainerStatus.ts b/frontend/packages/kube-types/src/openshift/V1ContainerStatus.ts new file mode 100644 index 00000000000..6b25ec44ba7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ContainerStatus.ts @@ -0,0 +1,70 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ContainerState } from './V1ContainerState'; + +/** + * ContainerStatus contains details for the current status of this container. + * @export + * @interface V1ContainerStatus + */ +export interface V1ContainerStatus { + /** + * Container\'s ID in the format \'docker://\'. + * @type {string} + * @memberof V1ContainerStatus + */ + containerID?: string; + /** + * The image the container is running. More info: https://kubernetes.io/docs/concepts/containers/images + * @type {string} + * @memberof V1ContainerStatus + */ + image: string; + /** + * ImageID of the container\'s image. + * @type {string} + * @memberof V1ContainerStatus + */ + imageID: string; + /** + * + * @type {V1ContainerState} + * @memberof V1ContainerStatus + */ + lastState?: V1ContainerState; + /** + * This must be a DNS_LABEL. Each container in a pod must have a unique name. Cannot be updated. + * @type {string} + * @memberof V1ContainerStatus + */ + name: string; + /** + * Specifies whether the container has passed its readiness probe. + * @type {boolean} + * @memberof V1ContainerStatus + */ + ready: boolean; + /** + * The number of times the container has been restarted, currently based on the number of dead containers that have not yet been removed. Note that this is calculated from dead containers. But those containers are subject to garbage collection. This value will get capped at 5 by GC. + * @type {number} + * @memberof V1ContainerStatus + */ + restartCount: number; + /** + * + * @type {V1ContainerState} + * @memberof V1ContainerStatus + */ + state?: V1ContainerState; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ControllerRevision.ts b/frontend/packages/kube-types/src/openshift/V1ControllerRevision.ts new file mode 100644 index 00000000000..bb2fa38bb64 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ControllerRevision.ts @@ -0,0 +1,53 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { IoK8sApimachineryPkgRuntimeRawExtension } from './IoK8sApimachineryPkgRuntimeRawExtension'; + +/** + * ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. + * @export + * @interface V1ControllerRevision + */ +export interface V1ControllerRevision { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ControllerRevision + */ + apiVersion?: string; + /** + * + * @type {IoK8sApimachineryPkgRuntimeRawExtension} + * @memberof V1ControllerRevision + */ + data?: IoK8sApimachineryPkgRuntimeRawExtension; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ControllerRevision + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1ControllerRevision + */ + metadata?: V1ObjectMeta; + /** + * Revision indicates the revision of the state represented by Data. + * @type {number} + * @memberof V1ControllerRevision + */ + revision: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ControllerRevisionList.ts b/frontend/packages/kube-types/src/openshift/V1ControllerRevisionList.ts new file mode 100644 index 00000000000..b1770bee201 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ControllerRevisionList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ControllerRevision } from './V1ControllerRevision'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ControllerRevisionList is a resource containing a list of ControllerRevision objects. + * @export + * @interface V1ControllerRevisionList + */ +export interface V1ControllerRevisionList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ControllerRevisionList + */ + apiVersion?: string; + /** + * Items is the list of ControllerRevisions + * @type {Array} + * @memberof V1ControllerRevisionList + */ + items: V1ControllerRevision[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ControllerRevisionList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1ControllerRevisionList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1CrossVersionObjectReference.ts b/frontend/packages/kube-types/src/openshift/V1CrossVersionObjectReference.ts new file mode 100644 index 00000000000..064be266883 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1CrossVersionObjectReference.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * CrossVersionObjectReference contains enough information to let you identify the referred resource. + * @export + * @interface V1CrossVersionObjectReference + */ +export interface V1CrossVersionObjectReference { + /** + * API version of the referent + * @type {string} + * @memberof V1CrossVersionObjectReference + */ + apiVersion?: string; + /** + * Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds\" + * @type {string} + * @memberof V1CrossVersionObjectReference + */ + kind: string; + /** + * Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names + * @type {string} + * @memberof V1CrossVersionObjectReference + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DaemonEndpoint.ts b/frontend/packages/kube-types/src/openshift/V1DaemonEndpoint.ts new file mode 100644 index 00000000000..8736cc95fc0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DaemonEndpoint.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DaemonEndpoint contains information about a single Daemon endpoint. + * @export + * @interface V1DaemonEndpoint + */ +export interface V1DaemonEndpoint { + /** + * Port number of the given endpoint. + * @type {number} + * @memberof V1DaemonEndpoint + */ + port: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DaemonSet.ts b/frontend/packages/kube-types/src/openshift/V1DaemonSet.ts new file mode 100644 index 00000000000..d7fcedb72c1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DaemonSet.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DaemonSetSpec } from './V1DaemonSetSpec'; +import { V1DaemonSetStatus } from './V1DaemonSetStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * DaemonSet represents the configuration of a daemon set. + * @export + * @interface V1DaemonSet + */ +export interface V1DaemonSet { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1DaemonSet + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1DaemonSet + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1DaemonSet + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1DaemonSetSpec} + * @memberof V1DaemonSet + */ + spec?: V1DaemonSetSpec; + /** + * + * @type {V1DaemonSetStatus} + * @memberof V1DaemonSet + */ + status?: V1DaemonSetStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DaemonSetCondition.ts b/frontend/packages/kube-types/src/openshift/V1DaemonSetCondition.ts new file mode 100644 index 00000000000..cd46bf16b83 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DaemonSetCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DaemonSetCondition describes the state of a DaemonSet at a certain point. + * @export + * @interface V1DaemonSetCondition + */ +export interface V1DaemonSetCondition { + /** + * + * @type {string} + * @memberof V1DaemonSetCondition + */ + lastTransitionTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof V1DaemonSetCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof V1DaemonSetCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1DaemonSetCondition + */ + status: string; + /** + * Type of DaemonSet condition. + * @type {string} + * @memberof V1DaemonSetCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DaemonSetList.ts b/frontend/packages/kube-types/src/openshift/V1DaemonSetList.ts new file mode 100644 index 00000000000..c69a6a7b676 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DaemonSetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DaemonSet } from './V1DaemonSet'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * DaemonSetList is a collection of daemon sets. + * @export + * @interface V1DaemonSetList + */ +export interface V1DaemonSetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1DaemonSetList + */ + apiVersion?: string; + /** + * A list of daemon sets. + * @type {Array} + * @memberof V1DaemonSetList + */ + items: V1DaemonSet[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1DaemonSetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1DaemonSetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DaemonSetSpec.ts b/frontend/packages/kube-types/src/openshift/V1DaemonSetSpec.ts new file mode 100644 index 00000000000..a6586c934b8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DaemonSetSpec.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DaemonSetUpdateStrategy } from './V1DaemonSetUpdateStrategy'; +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * DaemonSetSpec is the specification of a daemon set. + * @export + * @interface V1DaemonSetSpec + */ +export interface V1DaemonSetSpec { + /** + * The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). + * @type {number} + * @memberof V1DaemonSetSpec + */ + minReadySeconds?: number; + /** + * The number of old history to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. + * @type {number} + * @memberof V1DaemonSetSpec + */ + revisionHistoryLimit?: number; + /** + * + * @type {V1LabelSelector} + * @memberof V1DaemonSetSpec + */ + selector: V1LabelSelector; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1DaemonSetSpec + */ + template: V1PodTemplateSpec; + /** + * + * @type {V1DaemonSetUpdateStrategy} + * @memberof V1DaemonSetSpec + */ + updateStrategy?: V1DaemonSetUpdateStrategy; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DaemonSetStatus.ts b/frontend/packages/kube-types/src/openshift/V1DaemonSetStatus.ts new file mode 100644 index 00000000000..d653c8140d3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DaemonSetStatus.ts @@ -0,0 +1,82 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DaemonSetCondition } from './V1DaemonSetCondition'; + +/** + * DaemonSetStatus represents the current status of a daemon set. + * @export + * @interface V1DaemonSetStatus + */ +export interface V1DaemonSetStatus { + /** + * Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. + * @type {number} + * @memberof V1DaemonSetStatus + */ + collisionCount?: number; + /** + * Represents the latest available observations of a DaemonSet\'s current state. + * @type {Array} + * @memberof V1DaemonSetStatus + */ + conditions?: V1DaemonSetCondition[]; + /** + * The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ + * @type {number} + * @memberof V1DaemonSetStatus + */ + currentNumberScheduled: number; + /** + * The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ + * @type {number} + * @memberof V1DaemonSetStatus + */ + desiredNumberScheduled: number; + /** + * The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds) + * @type {number} + * @memberof V1DaemonSetStatus + */ + numberAvailable?: number; + /** + * The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ + * @type {number} + * @memberof V1DaemonSetStatus + */ + numberMisscheduled: number; + /** + * The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and ready. + * @type {number} + * @memberof V1DaemonSetStatus + */ + numberReady: number; + /** + * The number of nodes that should be running the daemon pod and have none of the daemon pod running and available (ready for at least spec.minReadySeconds) + * @type {number} + * @memberof V1DaemonSetStatus + */ + numberUnavailable?: number; + /** + * The most recent generation observed by the daemon set controller. + * @type {number} + * @memberof V1DaemonSetStatus + */ + observedGeneration?: number; + /** + * The total number of nodes that are running updated daemon pod + * @type {number} + * @memberof V1DaemonSetStatus + */ + updatedNumberScheduled?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DaemonSetUpdateStrategy.ts b/frontend/packages/kube-types/src/openshift/V1DaemonSetUpdateStrategy.ts new file mode 100644 index 00000000000..f6aa5e0c478 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DaemonSetUpdateStrategy.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1RollingUpdateDaemonSet } from './V1RollingUpdateDaemonSet'; + +/** + * DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet. + * @export + * @interface V1DaemonSetUpdateStrategy + */ +export interface V1DaemonSetUpdateStrategy { + /** + * + * @type {V1RollingUpdateDaemonSet} + * @memberof V1DaemonSetUpdateStrategy + */ + rollingUpdate?: V1RollingUpdateDaemonSet; + /** + * Type of daemon set update. Can be \"RollingUpdate\" or \"OnDelete\". Default is RollingUpdate. + * @type {string} + * @memberof V1DaemonSetUpdateStrategy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DeleteOptions.ts b/frontend/packages/kube-types/src/openshift/V1DeleteOptions.ts new file mode 100644 index 00000000000..e22a7f84da5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DeleteOptions.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Preconditions } from './V1Preconditions'; + +/** + * DeleteOptions may be provided when deleting an API object. + * @export + * @interface V1DeleteOptions + */ +export interface V1DeleteOptions { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1DeleteOptions + */ + apiVersion?: 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. + * @type {number} + * @memberof V1DeleteOptions + */ + gracePeriodSeconds?: number; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1DeleteOptions + */ + kind?: string; + /** + * Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object\'s finalizers list. Either this field or PropagationPolicy may be set, but not both. + * @type {boolean} + * @memberof V1DeleteOptions + */ + orphanDependents?: boolean; + /** + * + * @type {V1Preconditions} + * @memberof V1DeleteOptions + */ + preconditions?: V1Preconditions; + /** + * Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: \'Orphan\' - orphan the dependents; \'Background\' - allow the garbage collector to delete the dependents in the background; \'Foreground\' - a cascading policy that deletes all dependents in the foreground. + * @type {string} + * @memberof V1DeleteOptions + */ + propagationPolicy?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Deployment.ts b/frontend/packages/kube-types/src/openshift/V1Deployment.ts new file mode 100644 index 00000000000..b7ef3dd7ffc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Deployment.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DeploymentSpec } from './V1DeploymentSpec'; +import { V1DeploymentStatus } from './V1DeploymentStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Deployment enables declarative updates for Pods and ReplicaSets. + * @export + * @interface V1Deployment + */ +export interface V1Deployment { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Deployment + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Deployment + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Deployment + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1DeploymentSpec} + * @memberof V1Deployment + */ + spec?: V1DeploymentSpec; + /** + * + * @type {V1DeploymentStatus} + * @memberof V1Deployment + */ + status?: V1DeploymentStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DeploymentCondition.ts b/frontend/packages/kube-types/src/openshift/V1DeploymentCondition.ts new file mode 100644 index 00000000000..fd88d49ffcc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DeploymentCondition.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DeploymentCondition describes the state of a deployment at a certain point. + * @export + * @interface V1DeploymentCondition + */ +export interface V1DeploymentCondition { + /** + * + * @type {string} + * @memberof V1DeploymentCondition + */ + lastTransitionTime?: string; + /** + * + * @type {string} + * @memberof V1DeploymentCondition + */ + lastUpdateTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof V1DeploymentCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof V1DeploymentCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1DeploymentCondition + */ + status: string; + /** + * Type of deployment condition. + * @type {string} + * @memberof V1DeploymentCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DeploymentList.ts b/frontend/packages/kube-types/src/openshift/V1DeploymentList.ts new file mode 100644 index 00000000000..1e5cb636abf --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DeploymentList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Deployment } from './V1Deployment'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * DeploymentList is a list of Deployments. + * @export + * @interface V1DeploymentList + */ +export interface V1DeploymentList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1DeploymentList + */ + apiVersion?: string; + /** + * Items is the list of Deployments. + * @type {Array} + * @memberof V1DeploymentList + */ + items: V1Deployment[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1DeploymentList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1DeploymentList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DeploymentSpec.ts b/frontend/packages/kube-types/src/openshift/V1DeploymentSpec.ts new file mode 100644 index 00000000000..03119374c94 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DeploymentSpec.ts @@ -0,0 +1,72 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DeploymentStrategy } from './V1DeploymentStrategy'; +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * DeploymentSpec is the specification of the desired behavior of the Deployment. + * @export + * @interface V1DeploymentSpec + */ +export interface V1DeploymentSpec { + /** + * Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) + * @type {number} + * @memberof V1DeploymentSpec + */ + minReadySeconds?: number; + /** + * Indicates that the deployment is paused. + * @type {boolean} + * @memberof V1DeploymentSpec + */ + paused?: boolean; + /** + * The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s. + * @type {number} + * @memberof V1DeploymentSpec + */ + progressDeadlineSeconds?: number; + /** + * Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. + * @type {number} + * @memberof V1DeploymentSpec + */ + replicas?: number; + /** + * The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. + * @type {number} + * @memberof V1DeploymentSpec + */ + revisionHistoryLimit?: number; + /** + * + * @type {V1LabelSelector} + * @memberof V1DeploymentSpec + */ + selector: V1LabelSelector; + /** + * + * @type {V1DeploymentStrategy} + * @memberof V1DeploymentSpec + */ + strategy?: V1DeploymentStrategy; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1DeploymentSpec + */ + template: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DeploymentStatus.ts b/frontend/packages/kube-types/src/openshift/V1DeploymentStatus.ts new file mode 100644 index 00000000000..acf7b69a13d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DeploymentStatus.ts @@ -0,0 +1,70 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DeploymentCondition } from './V1DeploymentCondition'; + +/** + * DeploymentStatus is the most recently observed status of the Deployment. + * @export + * @interface V1DeploymentStatus + */ +export interface V1DeploymentStatus { + /** + * Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. + * @type {number} + * @memberof V1DeploymentStatus + */ + availableReplicas?: number; + /** + * Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet. + * @type {number} + * @memberof V1DeploymentStatus + */ + collisionCount?: number; + /** + * Represents the latest available observations of a deployment\'s current state. + * @type {Array} + * @memberof V1DeploymentStatus + */ + conditions?: V1DeploymentCondition[]; + /** + * The generation observed by the deployment controller. + * @type {number} + * @memberof V1DeploymentStatus + */ + observedGeneration?: number; + /** + * Total number of ready pods targeted by this deployment. + * @type {number} + * @memberof V1DeploymentStatus + */ + readyReplicas?: number; + /** + * Total number of non-terminated pods targeted by this deployment (their labels match the selector). + * @type {number} + * @memberof V1DeploymentStatus + */ + replicas?: number; + /** + * Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created. + * @type {number} + * @memberof V1DeploymentStatus + */ + unavailableReplicas?: number; + /** + * Total number of non-terminated pods targeted by this deployment that have the desired template spec. + * @type {number} + * @memberof V1DeploymentStatus + */ + updatedReplicas?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DeploymentStrategy.ts b/frontend/packages/kube-types/src/openshift/V1DeploymentStrategy.ts new file mode 100644 index 00000000000..83ea487a2d3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DeploymentStrategy.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1RollingUpdateDeployment } from './V1RollingUpdateDeployment'; + +/** + * DeploymentStrategy describes how to replace existing pods with new ones. + * @export + * @interface V1DeploymentStrategy + */ +export interface V1DeploymentStrategy { + /** + * + * @type {V1RollingUpdateDeployment} + * @memberof V1DeploymentStrategy + */ + rollingUpdate?: V1RollingUpdateDeployment; + /** + * Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate. + * @type {string} + * @memberof V1DeploymentStrategy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DownwardAPIProjection.ts b/frontend/packages/kube-types/src/openshift/V1DownwardAPIProjection.ts new file mode 100644 index 00000000000..4af0b301e30 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DownwardAPIProjection.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DownwardAPIVolumeFile } from './V1DownwardAPIVolumeFile'; + +/** + * Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode. + * @export + * @interface V1DownwardAPIProjection + */ +export interface V1DownwardAPIProjection { + /** + * Items is a list of DownwardAPIVolume file + * @type {Array} + * @memberof V1DownwardAPIProjection + */ + items?: V1DownwardAPIVolumeFile[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DownwardAPIVolumeFile.ts b/frontend/packages/kube-types/src/openshift/V1DownwardAPIVolumeFile.ts new file mode 100644 index 00000000000..ef46d26ae98 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DownwardAPIVolumeFile.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectFieldSelector } from './V1ObjectFieldSelector'; +import { V1ResourceFieldSelector } from './V1ResourceFieldSelector'; + +/** + * DownwardAPIVolumeFile represents information to create the file containing the pod field + * @export + * @interface V1DownwardAPIVolumeFile + */ +export interface V1DownwardAPIVolumeFile { + /** + * + * @type {V1ObjectFieldSelector} + * @memberof V1DownwardAPIVolumeFile + */ + fieldRef?: V1ObjectFieldSelector; + /** + * Optional: mode bits to use on this file, must be a value between 0 and 0777. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. + * @type {number} + * @memberof V1DownwardAPIVolumeFile + */ + mode?: number; + /** + * Required: Path is the relative path name of the file to be created. Must not be absolute or contain the \'..\' path. Must be utf-8 encoded. The first item of the relative path must not start with \'..\' + * @type {string} + * @memberof V1DownwardAPIVolumeFile + */ + path: string; + /** + * + * @type {V1ResourceFieldSelector} + * @memberof V1DownwardAPIVolumeFile + */ + resourceFieldRef?: V1ResourceFieldSelector; +} diff --git a/frontend/packages/kube-types/src/openshift/V1DownwardAPIVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1DownwardAPIVolumeSource.ts new file mode 100644 index 00000000000..33e03effef0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1DownwardAPIVolumeSource.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DownwardAPIVolumeFile } from './V1DownwardAPIVolumeFile'; + +/** + * DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling. + * @export + * @interface V1DownwardAPIVolumeSource + */ +export interface V1DownwardAPIVolumeSource { + /** + * Optional: mode bits to use on created files by default. Must be a value between 0 and 0777. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. + * @type {number} + * @memberof V1DownwardAPIVolumeSource + */ + defaultMode?: number; + /** + * Items is a list of downward API volume file + * @type {Array} + * @memberof V1DownwardAPIVolumeSource + */ + items?: V1DownwardAPIVolumeFile[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1EmptyDirVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1EmptyDirVolumeSource.ts new file mode 100644 index 00000000000..856775f885a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1EmptyDirVolumeSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling. + * @export + * @interface V1EmptyDirVolumeSource + */ +export interface V1EmptyDirVolumeSource { + /** + * What type of storage medium should back this directory. The default is \"\" which means to use the node\'s default medium. Must be an empty string (default) or Memory. More info: https://kubernetes.io/docs/concepts/storage/volumes#emptydir + * @type {string} + * @memberof V1EmptyDirVolumeSource + */ + medium?: string; + /** + * + * @type {string} + * @memberof V1EmptyDirVolumeSource + */ + sizeLimit?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1EndpointAddress.ts b/frontend/packages/kube-types/src/openshift/V1EndpointAddress.ts new file mode 100644 index 00000000000..3e2fe03bf3b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1EndpointAddress.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * EndpointAddress is a tuple that describes single IP address. + * @export + * @interface V1EndpointAddress + */ +export interface V1EndpointAddress { + /** + * The Hostname of this endpoint + * @type {string} + * @memberof V1EndpointAddress + */ + hostname?: string; + /** + * The IP of this endpoint. May not be loopback (127.0.0.0/8), link-local (169.254.0.0/16), or link-local multicast ((224.0.0.0/24). IPv6 is also accepted but not fully supported on all platforms. Also, certain kubernetes components, like kube-proxy, are not IPv6 ready. + * @type {string} + * @memberof V1EndpointAddress + */ + ip: string; + /** + * Optional: Node hosting this endpoint. This can be used to determine endpoints local to a node. + * @type {string} + * @memberof V1EndpointAddress + */ + nodeName?: string; + /** + * + * @type {V1ObjectReference} + * @memberof V1EndpointAddress + */ + targetRef?: V1ObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/V1EndpointPort.ts b/frontend/packages/kube-types/src/openshift/V1EndpointPort.ts new file mode 100644 index 00000000000..72795d62de1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1EndpointPort.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * EndpointPort is a tuple that describes a single port. + * @export + * @interface V1EndpointPort + */ +export interface V1EndpointPort { + /** + * The name of this port (corresponds to ServicePort.Name). Must be a DNS_LABEL. Optional only if one port is defined. + * @type {string} + * @memberof V1EndpointPort + */ + name?: string; + /** + * The port number of the endpoint. + * @type {number} + * @memberof V1EndpointPort + */ + port: number; + /** + * The IP protocol for this port. Must be UDP or TCP. Default is TCP. + * @type {string} + * @memberof V1EndpointPort + */ + protocol?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1EndpointSubset.ts b/frontend/packages/kube-types/src/openshift/V1EndpointSubset.ts new file mode 100644 index 00000000000..d9d6dfd72af --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1EndpointSubset.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1EndpointAddress } from './V1EndpointAddress'; +import { V1EndpointPort } from './V1EndpointPort'; + +/** + * EndpointSubset is a group of addresses with a common set of ports. The expanded set of endpoints is the Cartesian product of Addresses x Ports. For example, given: { Addresses: [{\"ip\": \"10.10.1.1\"}, {\"ip\": \"10.10.2.2\"}], Ports: [{\"name\": \"a\", \"port\": 8675}, {\"name\": \"b\", \"port\": 309}] } The resulting set of endpoints can be viewed as: a: [ 10.10.1.1:8675, 10.10.2.2:8675 ], b: [ 10.10.1.1:309, 10.10.2.2:309 ] + * @export + * @interface V1EndpointSubset + */ +export interface V1EndpointSubset { + /** + * IP addresses which offer the related ports that are marked as ready. These endpoints should be considered safe for load balancers and clients to utilize. + * @type {Array} + * @memberof V1EndpointSubset + */ + addresses?: V1EndpointAddress[]; + /** + * IP addresses which offer the related ports but are not currently marked as ready because they have not yet finished starting, have recently failed a readiness check, or have recently failed a liveness check. + * @type {Array} + * @memberof V1EndpointSubset + */ + notReadyAddresses?: V1EndpointAddress[]; + /** + * Port numbers available on the related IP addresses. + * @type {Array} + * @memberof V1EndpointSubset + */ + ports?: V1EndpointPort[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Endpoints.ts b/frontend/packages/kube-types/src/openshift/V1Endpoints.ts new file mode 100644 index 00000000000..4bd3dcd70df --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Endpoints.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1EndpointSubset } from './V1EndpointSubset'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Endpoints is a collection of endpoints that implement the actual service. Example: Name: \"mysvc\", Subsets: [ { Addresses: [{\"ip\": \"10.10.1.1\"}, {\"ip\": \"10.10.2.2\"}], Ports: [{\"name\": \"a\", \"port\": 8675}, {\"name\": \"b\", \"port\": 309}] }, { Addresses: [{\"ip\": \"10.10.3.3\"}], Ports: [{\"name\": \"a\", \"port\": 93}, {\"name\": \"b\", \"port\": 76}] }, ] + * @export + * @interface V1Endpoints + */ +export interface V1Endpoints { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Endpoints + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Endpoints + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Endpoints + */ + metadata?: V1ObjectMeta; + /** + * The set of all endpoints is the union of all subsets. Addresses are placed into subsets according to the IPs they share. A single address with multiple ports, some of which are ready and some of which are not (because they come from different containers) will result in the address being displayed in different subsets for the different ports. No address will appear in both Addresses and NotReadyAddresses in the same subset. Sets of addresses and ports that comprise a service. + * @type {Array} + * @memberof V1Endpoints + */ + subsets?: V1EndpointSubset[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1EndpointsList.ts b/frontend/packages/kube-types/src/openshift/V1EndpointsList.ts new file mode 100644 index 00000000000..2afd239a29e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1EndpointsList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Endpoints } from './V1Endpoints'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * EndpointsList is a list of endpoints. + * @export + * @interface V1EndpointsList + */ +export interface V1EndpointsList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1EndpointsList + */ + apiVersion?: string; + /** + * List of endpoints. + * @type {Array} + * @memberof V1EndpointsList + */ + items: V1Endpoints[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1EndpointsList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1EndpointsList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1EnvFromSource.ts b/frontend/packages/kube-types/src/openshift/V1EnvFromSource.ts new file mode 100644 index 00000000000..8de5d83fb05 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1EnvFromSource.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ConfigMapEnvSource } from './V1ConfigMapEnvSource'; +import { V1SecretEnvSource } from './V1SecretEnvSource'; + +/** + * EnvFromSource represents the source of a set of ConfigMaps + * @export + * @interface V1EnvFromSource + */ +export interface V1EnvFromSource { + /** + * + * @type {V1ConfigMapEnvSource} + * @memberof V1EnvFromSource + */ + configMapRef?: V1ConfigMapEnvSource; + /** + * An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER. + * @type {string} + * @memberof V1EnvFromSource + */ + prefix?: string; + /** + * + * @type {V1SecretEnvSource} + * @memberof V1EnvFromSource + */ + secretRef?: V1SecretEnvSource; +} diff --git a/frontend/packages/kube-types/src/openshift/V1EnvVar.ts b/frontend/packages/kube-types/src/openshift/V1EnvVar.ts new file mode 100644 index 00000000000..cbdf9919867 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1EnvVar.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1EnvVarSource } from './V1EnvVarSource'; + +/** + * EnvVar represents an environment variable present in a Container. + * @export + * @interface V1EnvVar + */ +export interface V1EnvVar { + /** + * Name of the environment variable. Must be a C_IDENTIFIER. + * @type {string} + * @memberof V1EnvVar + */ + name: string; + /** + * Variable references $(VAR_NAME) are expanded using the previous defined environment variables in the container and any service environment variables. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to \"\". + * @type {string} + * @memberof V1EnvVar + */ + value?: string; + /** + * + * @type {V1EnvVarSource} + * @memberof V1EnvVar + */ + valueFrom?: V1EnvVarSource; +} diff --git a/frontend/packages/kube-types/src/openshift/V1EnvVarSource.ts b/frontend/packages/kube-types/src/openshift/V1EnvVarSource.ts new file mode 100644 index 00000000000..ffe3526c86d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1EnvVarSource.ts @@ -0,0 +1,49 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ConfigMapKeySelector } from './V1ConfigMapKeySelector'; +import { V1ObjectFieldSelector } from './V1ObjectFieldSelector'; +import { V1ResourceFieldSelector } from './V1ResourceFieldSelector'; +import { V1SecretKeySelector } from './V1SecretKeySelector'; + +/** + * EnvVarSource represents a source for the value of an EnvVar. + * @export + * @interface V1EnvVarSource + */ +export interface V1EnvVarSource { + /** + * + * @type {V1ConfigMapKeySelector} + * @memberof V1EnvVarSource + */ + configMapKeyRef?: V1ConfigMapKeySelector; + /** + * + * @type {V1ObjectFieldSelector} + * @memberof V1EnvVarSource + */ + fieldRef?: V1ObjectFieldSelector; + /** + * + * @type {V1ResourceFieldSelector} + * @memberof V1EnvVarSource + */ + resourceFieldRef?: V1ResourceFieldSelector; + /** + * + * @type {V1SecretKeySelector} + * @memberof V1EnvVarSource + */ + secretKeyRef?: V1SecretKeySelector; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Event.ts b/frontend/packages/kube-types/src/openshift/V1Event.ts new file mode 100644 index 00000000000..6f48b9476dd --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Event.ts @@ -0,0 +1,127 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1EventSeries } from './V1EventSeries'; +import { V1EventSource } from './V1EventSource'; +import { V1ObjectReference } from './V1ObjectReference'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Event is a report of an event somewhere in the cluster. + * @export + * @interface V1Event + */ +export interface V1Event { + /** + * What action was taken/failed regarding to the Regarding object. + * @type {string} + * @memberof V1Event + */ + action?: string; + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Event + */ + apiVersion?: string; + /** + * The number of times this event has occurred. + * @type {number} + * @memberof V1Event + */ + count?: number; + /** + * + * @type {string} + * @memberof V1Event + */ + eventTime?: string; + /** + * + * @type {string} + * @memberof V1Event + */ + firstTimestamp?: string; + /** + * + * @type {V1ObjectReference} + * @memberof V1Event + */ + involvedObject: V1ObjectReference; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Event + */ + kind?: string; + /** + * + * @type {string} + * @memberof V1Event + */ + lastTimestamp?: string; + /** + * A human-readable description of the status of this operation. + * @type {string} + * @memberof V1Event + */ + message?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Event + */ + metadata: V1ObjectMeta; + /** + * This should be a short, machine understandable string that gives the reason for the transition into the object\'s current status. + * @type {string} + * @memberof V1Event + */ + reason?: string; + /** + * + * @type {V1ObjectReference} + * @memberof V1Event + */ + related?: V1ObjectReference; + /** + * Name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`. + * @type {string} + * @memberof V1Event + */ + reportingComponent?: string; + /** + * ID of the controller instance, e.g. `kubelet-xyzf`. + * @type {string} + * @memberof V1Event + */ + reportingInstance?: string; + /** + * + * @type {V1EventSeries} + * @memberof V1Event + */ + series?: V1EventSeries; + /** + * + * @type {V1EventSource} + * @memberof V1Event + */ + source?: V1EventSource; + /** + * Type of this event (Normal, Warning), new types could be added in the future + * @type {string} + * @memberof V1Event + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1EventList.ts b/frontend/packages/kube-types/src/openshift/V1EventList.ts new file mode 100644 index 00000000000..9443d1d47b5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1EventList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Event } from './V1Event'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * EventList is a list of events. + * @export + * @interface V1EventList + */ +export interface V1EventList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1EventList + */ + apiVersion?: string; + /** + * List of events + * @type {Array} + * @memberof V1EventList + */ + items: V1Event[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1EventList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1EventList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1EventSeries.ts b/frontend/packages/kube-types/src/openshift/V1EventSeries.ts new file mode 100644 index 00000000000..0fe68cae439 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1EventSeries.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. + * @export + * @interface V1EventSeries + */ +export interface V1EventSeries { + /** + * Number of occurrences in this series up to the last heartbeat time + * @type {number} + * @memberof V1EventSeries + */ + count?: number; + /** + * + * @type {string} + * @memberof V1EventSeries + */ + lastObservedTime?: string; + /** + * State of this Series: Ongoing or Finished + * @type {string} + * @memberof V1EventSeries + */ + state?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1EventSource.ts b/frontend/packages/kube-types/src/openshift/V1EventSource.ts new file mode 100644 index 00000000000..babdef57832 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1EventSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * EventSource contains information for an event. + * @export + * @interface V1EventSource + */ +export interface V1EventSource { + /** + * Component from which the event is generated. + * @type {string} + * @memberof V1EventSource + */ + component?: string; + /** + * Node name on which the event is generated. + * @type {string} + * @memberof V1EventSource + */ + host?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ExecAction.ts b/frontend/packages/kube-types/src/openshift/V1ExecAction.ts new file mode 100644 index 00000000000..5eac07640b7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ExecAction.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ExecAction describes a \"run in container\" action. + * @export + * @interface V1ExecAction + */ +export interface V1ExecAction { + /** + * Command is the command line to execute inside the container, the working directory for the command is root (\'/\') in the container\'s filesystem. The command is simply exec\'d, it is not run inside a shell, so traditional shell instructions (\'|\', etc) won\'t work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. + * @type {Array} + * @memberof V1ExecAction + */ + command?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1FCVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1FCVolumeSource.ts new file mode 100644 index 00000000000..58c38019477 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1FCVolumeSource.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a Fibre Channel volume. Fibre Channel volumes can only be mounted as read/write once. Fibre Channel volumes support ownership management and SELinux relabeling. + * @export + * @interface V1FCVolumeSource + */ +export interface V1FCVolumeSource { + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. + * @type {string} + * @memberof V1FCVolumeSource + */ + fsType?: string; + /** + * Optional: FC target lun number + * @type {number} + * @memberof V1FCVolumeSource + */ + lun?: number; + /** + * Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. + * @type {boolean} + * @memberof V1FCVolumeSource + */ + readOnly?: boolean; + /** + * Optional: FC target worldwide names (WWNs) + * @type {Array} + * @memberof V1FCVolumeSource + */ + targetWWNs?: string[]; + /** + * Optional: FC volume world wide identifiers (wwids) Either wwids or combination of targetWWNs and lun must be set, but not both simultaneously. + * @type {Array} + * @memberof V1FCVolumeSource + */ + wwids?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1FlexPersistentVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1FlexPersistentVolumeSource.ts new file mode 100644 index 00000000000..b112e5e1af5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1FlexPersistentVolumeSource.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SecretReference } from './V1SecretReference'; + +/** + * FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin. + * @export + * @interface V1FlexPersistentVolumeSource + */ +export interface V1FlexPersistentVolumeSource { + /** + * Driver is the name of the driver to use for this volume. + * @type {string} + * @memberof V1FlexPersistentVolumeSource + */ + driver: string; + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script. + * @type {string} + * @memberof V1FlexPersistentVolumeSource + */ + fsType?: string; + /** + * Optional: Extra command options if any. + * @type {{ [key: string]: string; }} + * @memberof V1FlexPersistentVolumeSource + */ + options?: { [key: string]: string }; + /** + * Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. + * @type {boolean} + * @memberof V1FlexPersistentVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1SecretReference} + * @memberof V1FlexPersistentVolumeSource + */ + secretRef?: V1SecretReference; +} diff --git a/frontend/packages/kube-types/src/openshift/V1FlexVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1FlexVolumeSource.ts new file mode 100644 index 00000000000..44af99189e0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1FlexVolumeSource.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin. + * @export + * @interface V1FlexVolumeSource + */ +export interface V1FlexVolumeSource { + /** + * Driver is the name of the driver to use for this volume. + * @type {string} + * @memberof V1FlexVolumeSource + */ + driver: string; + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". The default filesystem depends on FlexVolume script. + * @type {string} + * @memberof V1FlexVolumeSource + */ + fsType?: string; + /** + * Optional: Extra command options if any. + * @type {{ [key: string]: string; }} + * @memberof V1FlexVolumeSource + */ + options?: { [key: string]: string }; + /** + * Optional: Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. + * @type {boolean} + * @memberof V1FlexVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1FlexVolumeSource + */ + secretRef?: V1LocalObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/V1FlockerVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1FlockerVolumeSource.ts new file mode 100644 index 00000000000..b8e8abbb82c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1FlockerVolumeSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a Flocker volume mounted by the Flocker agent. One and only one of datasetName and datasetUUID should be set. Flocker volumes do not support ownership management or SELinux relabeling. + * @export + * @interface V1FlockerVolumeSource + */ +export interface V1FlockerVolumeSource { + /** + * Name of the dataset stored as metadata -> name on the dataset for Flocker should be considered as deprecated + * @type {string} + * @memberof V1FlockerVolumeSource + */ + datasetName?: string; + /** + * UUID of the dataset. This is unique identifier of a Flocker dataset + * @type {string} + * @memberof V1FlockerVolumeSource + */ + datasetUUID?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1GCEPersistentDiskVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1GCEPersistentDiskVolumeSource.ts new file mode 100644 index 00000000000..9c4637a20bc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1GCEPersistentDiskVolumeSource.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a Persistent Disk resource in Google Compute Engine. A GCE PD must exist before mounting to a container. The disk must also be in the same GCE project and zone as the kubelet. A GCE PD can only be mounted as read/write once or read-only many times. GCE PDs support ownership management and SELinux relabeling. + * @export + * @interface V1GCEPersistentDiskVolumeSource + */ +export interface V1GCEPersistentDiskVolumeSource { + /** + * Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk + * @type {string} + * @memberof V1GCEPersistentDiskVolumeSource + */ + fsType?: string; + /** + * The partition in the volume that you want to mount. If omitted, the default is to mount by volume name. Examples: For volume /dev/sda1, you specify the partition as \"1\". Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty). More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk + * @type {number} + * @memberof V1GCEPersistentDiskVolumeSource + */ + partition?: number; + /** + * Unique name of the PD resource in GCE. Used to identify the disk in GCE. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk + * @type {string} + * @memberof V1GCEPersistentDiskVolumeSource + */ + pdName: string; + /** + * ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk + * @type {boolean} + * @memberof V1GCEPersistentDiskVolumeSource + */ + readOnly?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1GitRepoVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1GitRepoVolumeSource.ts new file mode 100644 index 00000000000..547bae6f438 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1GitRepoVolumeSource.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling. DEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod\'s container. + * @export + * @interface V1GitRepoVolumeSource + */ +export interface V1GitRepoVolumeSource { + /** + * Target directory name. Must not contain or start with \'..\'. If \'.\' is supplied, the volume directory will be the git repository. Otherwise, if specified, the volume will contain the git repository in the subdirectory with the given name. + * @type {string} + * @memberof V1GitRepoVolumeSource + */ + directory?: string; + /** + * Repository URL + * @type {string} + * @memberof V1GitRepoVolumeSource + */ + repository: string; + /** + * Commit hash for the specified revision. + * @type {string} + * @memberof V1GitRepoVolumeSource + */ + revision?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1GlusterfsVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1GlusterfsVolumeSource.ts new file mode 100644 index 00000000000..c57288ab525 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1GlusterfsVolumeSource.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling. + * @export + * @interface V1GlusterfsVolumeSource + */ +export interface V1GlusterfsVolumeSource { + /** + * EndpointsName is the endpoint name that details Glusterfs topology. More info: https://releases.k8s.io/HEAD/examples/volumes/glusterfs/README.md#create-a-pod + * @type {string} + * @memberof V1GlusterfsVolumeSource + */ + endpoints: string; + /** + * Path is the Glusterfs volume path. More info: https://releases.k8s.io/HEAD/examples/volumes/glusterfs/README.md#create-a-pod + * @type {string} + * @memberof V1GlusterfsVolumeSource + */ + path: string; + /** + * ReadOnly here will force the Glusterfs volume to be mounted with read-only permissions. Defaults to false. More info: https://releases.k8s.io/HEAD/examples/volumes/glusterfs/README.md#create-a-pod + * @type {boolean} + * @memberof V1GlusterfsVolumeSource + */ + readOnly?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1GroupVersionForDiscovery.ts b/frontend/packages/kube-types/src/openshift/V1GroupVersionForDiscovery.ts new file mode 100644 index 00000000000..296024c12da --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1GroupVersionForDiscovery.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * GroupVersion contains the \"group/version\" and \"version\" string of a version. It is made a struct to keep extensibility. + * @export + * @interface V1GroupVersionForDiscovery + */ +export interface V1GroupVersionForDiscovery { + /** + * groupVersion specifies the API group and version in the form \"group/version\" + * @type {string} + * @memberof V1GroupVersionForDiscovery + */ + groupVersion: string; + /** + * version specifies the version in the form of \"version\". This is to save the clients the trouble of splitting the GroupVersion. + * @type {string} + * @memberof V1GroupVersionForDiscovery + */ + version: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1HTTPGetAction.ts b/frontend/packages/kube-types/src/openshift/V1HTTPGetAction.ts new file mode 100644 index 00000000000..705c321145d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1HTTPGetAction.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1HTTPHeader } from './V1HTTPHeader'; + +/** + * HTTPGetAction describes an action based on HTTP Get requests. + * @export + * @interface V1HTTPGetAction + */ +export interface V1HTTPGetAction { + /** + * Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead. + * @type {string} + * @memberof V1HTTPGetAction + */ + host?: string; + /** + * Custom headers to set in the request. HTTP allows repeated headers. + * @type {Array} + * @memberof V1HTTPGetAction + */ + httpHeaders?: V1HTTPHeader[]; + /** + * Path to access on the HTTP server. + * @type {string} + * @memberof V1HTTPGetAction + */ + path?: string; + /** + * + * @type {string} + * @memberof V1HTTPGetAction + */ + port: string; + /** + * Scheme to use for connecting to the host. Defaults to HTTP. + * @type {string} + * @memberof V1HTTPGetAction + */ + scheme?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1HTTPHeader.ts b/frontend/packages/kube-types/src/openshift/V1HTTPHeader.ts new file mode 100644 index 00000000000..396f02e862f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1HTTPHeader.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * HTTPHeader describes a custom header to be used in HTTP probes + * @export + * @interface V1HTTPHeader + */ +export interface V1HTTPHeader { + /** + * The header field name + * @type {string} + * @memberof V1HTTPHeader + */ + name: string; + /** + * The header field value + * @type {string} + * @memberof V1HTTPHeader + */ + value: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Handler.ts b/frontend/packages/kube-types/src/openshift/V1Handler.ts new file mode 100644 index 00000000000..77ffefb63a6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Handler.ts @@ -0,0 +1,42 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ExecAction } from './V1ExecAction'; +import { V1HTTPGetAction } from './V1HTTPGetAction'; +import { V1TCPSocketAction } from './V1TCPSocketAction'; + +/** + * Handler defines a specific action that should be taken + * @export + * @interface V1Handler + */ +export interface V1Handler { + /** + * + * @type {V1ExecAction} + * @memberof V1Handler + */ + exec?: V1ExecAction; + /** + * + * @type {V1HTTPGetAction} + * @memberof V1Handler + */ + httpGet?: V1HTTPGetAction; + /** + * + * @type {V1TCPSocketAction} + * @memberof V1Handler + */ + tcpSocket?: V1TCPSocketAction; +} diff --git a/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscaler.ts b/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscaler.ts new file mode 100644 index 00000000000..a74111d59a6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscaler.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1HorizontalPodAutoscalerSpec } from './V1HorizontalPodAutoscalerSpec'; +import { V1HorizontalPodAutoscalerStatus } from './V1HorizontalPodAutoscalerStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * configuration of a horizontal pod autoscaler. + * @export + * @interface V1HorizontalPodAutoscaler + */ +export interface V1HorizontalPodAutoscaler { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1HorizontalPodAutoscaler + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1HorizontalPodAutoscaler + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1HorizontalPodAutoscaler + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1HorizontalPodAutoscalerSpec} + * @memberof V1HorizontalPodAutoscaler + */ + spec?: V1HorizontalPodAutoscalerSpec; + /** + * + * @type {V1HorizontalPodAutoscalerStatus} + * @memberof V1HorizontalPodAutoscaler + */ + status?: V1HorizontalPodAutoscalerStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerList.ts b/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerList.ts new file mode 100644 index 00000000000..e1d416b1b4d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1HorizontalPodAutoscaler } from './V1HorizontalPodAutoscaler'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * list of horizontal pod autoscaler objects. + * @export + * @interface V1HorizontalPodAutoscalerList + */ +export interface V1HorizontalPodAutoscalerList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1HorizontalPodAutoscalerList + */ + apiVersion?: string; + /** + * list of horizontal pod autoscaler objects. + * @type {Array} + * @memberof V1HorizontalPodAutoscalerList + */ + items: V1HorizontalPodAutoscaler[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1HorizontalPodAutoscalerList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1HorizontalPodAutoscalerList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerSpec.ts b/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerSpec.ts new file mode 100644 index 00000000000..9aa260385a9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerSpec.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1CrossVersionObjectReference } from './V1CrossVersionObjectReference'; + +/** + * specification of a horizontal pod autoscaler. + * @export + * @interface V1HorizontalPodAutoscalerSpec + */ +export interface V1HorizontalPodAutoscalerSpec { + /** + * upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas. + * @type {number} + * @memberof V1HorizontalPodAutoscalerSpec + */ + maxReplicas: number; + /** + * lower limit for the number of pods that can be set by the autoscaler, default 1. + * @type {number} + * @memberof V1HorizontalPodAutoscalerSpec + */ + minReplicas?: number; + /** + * + * @type {V1CrossVersionObjectReference} + * @memberof V1HorizontalPodAutoscalerSpec + */ + scaleTargetRef: V1CrossVersionObjectReference; + /** + * target average CPU utilization (represented as a percentage of requested CPU) over all the pods; if not specified the default autoscaling policy will be used. + * @type {number} + * @memberof V1HorizontalPodAutoscalerSpec + */ + targetCPUUtilizationPercentage?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerStatus.ts b/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerStatus.ts new file mode 100644 index 00000000000..f99a3d6e1cc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1HorizontalPodAutoscalerStatus.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * current status of a horizontal pod autoscaler + * @export + * @interface V1HorizontalPodAutoscalerStatus + */ +export interface V1HorizontalPodAutoscalerStatus { + /** + * current average CPU utilization over all pods, represented as a percentage of requested CPU, e.g. 70 means that an average pod is using now 70% of its requested CPU. + * @type {number} + * @memberof V1HorizontalPodAutoscalerStatus + */ + currentCPUUtilizationPercentage?: number; + /** + * current number of replicas of pods managed by this autoscaler. + * @type {number} + * @memberof V1HorizontalPodAutoscalerStatus + */ + currentReplicas: number; + /** + * desired number of replicas of pods managed by this autoscaler. + * @type {number} + * @memberof V1HorizontalPodAutoscalerStatus + */ + desiredReplicas: number; + /** + * + * @type {string} + * @memberof V1HorizontalPodAutoscalerStatus + */ + lastScaleTime?: string; + /** + * most recent generation observed by this autoscaler. + * @type {number} + * @memberof V1HorizontalPodAutoscalerStatus + */ + observedGeneration?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1HostAlias.ts b/frontend/packages/kube-types/src/openshift/V1HostAlias.ts new file mode 100644 index 00000000000..7d05d00385a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1HostAlias.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod\'s hosts file. + * @export + * @interface V1HostAlias + */ +export interface V1HostAlias { + /** + * Hostnames for the above IP address. + * @type {Array} + * @memberof V1HostAlias + */ + hostnames?: string[]; + /** + * IP address of the host file entry. + * @type {string} + * @memberof V1HostAlias + */ + ip?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1HostPathVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1HostPathVolumeSource.ts new file mode 100644 index 00000000000..7d8f501d203 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1HostPathVolumeSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling. + * @export + * @interface V1HostPathVolumeSource + */ +export interface V1HostPathVolumeSource { + /** + * Path of the directory on the host. If the path is a symlink, it will follow the link to the real path. More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath + * @type {string} + * @memberof V1HostPathVolumeSource + */ + path: string; + /** + * Type for HostPath Volume Defaults to \"\" More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath + * @type {string} + * @memberof V1HostPathVolumeSource + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1IPBlock.ts b/frontend/packages/kube-types/src/openshift/V1IPBlock.ts new file mode 100644 index 00000000000..ea291b6b5e9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1IPBlock.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * IPBlock describes a particular CIDR (Ex. \"192.168.1.1/24\") that is allowed to the pods matched by a NetworkPolicySpec\'s podSelector. The except entry describes CIDRs that should not be included within this rule. + * @export + * @interface V1IPBlock + */ +export interface V1IPBlock { + /** + * CIDR is a string representing the IP Block Valid examples are \"192.168.1.1/24\" + * @type {string} + * @memberof V1IPBlock + */ + cidr: string; + /** + * Except is a slice of CIDRs that should not be included within an IP Block Valid examples are \"192.168.1.1/24\" Except values will be rejected if they are outside the CIDR range + * @type {Array} + * @memberof V1IPBlock + */ + except?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ISCSIPersistentVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1ISCSIPersistentVolumeSource.ts new file mode 100644 index 00000000000..9fdfbf053d2 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ISCSIPersistentVolumeSource.ts @@ -0,0 +1,88 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SecretReference } from './V1SecretReference'; + +/** + * ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling. + * @export + * @interface V1ISCSIPersistentVolumeSource + */ +export interface V1ISCSIPersistentVolumeSource { + /** + * whether support iSCSI Discovery CHAP authentication + * @type {boolean} + * @memberof V1ISCSIPersistentVolumeSource + */ + chapAuthDiscovery?: boolean; + /** + * whether support iSCSI Session CHAP authentication + * @type {boolean} + * @memberof V1ISCSIPersistentVolumeSource + */ + chapAuthSession?: boolean; + /** + * Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi + * @type {string} + * @memberof V1ISCSIPersistentVolumeSource + */ + fsType?: string; + /** + * Custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection. + * @type {string} + * @memberof V1ISCSIPersistentVolumeSource + */ + initiatorName?: string; + /** + * Target iSCSI Qualified Name. + * @type {string} + * @memberof V1ISCSIPersistentVolumeSource + */ + iqn: string; + /** + * iSCSI Interface Name that uses an iSCSI transport. Defaults to \'default\' (tcp). + * @type {string} + * @memberof V1ISCSIPersistentVolumeSource + */ + iscsiInterface?: string; + /** + * iSCSI Target Lun number. + * @type {number} + * @memberof V1ISCSIPersistentVolumeSource + */ + lun: number; + /** + * iSCSI Target Portal List. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). + * @type {Array} + * @memberof V1ISCSIPersistentVolumeSource + */ + portals?: string[]; + /** + * ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. + * @type {boolean} + * @memberof V1ISCSIPersistentVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1SecretReference} + * @memberof V1ISCSIPersistentVolumeSource + */ + secretRef?: V1SecretReference; + /** + * iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). + * @type {string} + * @memberof V1ISCSIPersistentVolumeSource + */ + targetPortal: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ISCSIVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1ISCSIVolumeSource.ts new file mode 100644 index 00000000000..2f40c1d8fcc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ISCSIVolumeSource.ts @@ -0,0 +1,88 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling. + * @export + * @interface V1ISCSIVolumeSource + */ +export interface V1ISCSIVolumeSource { + /** + * whether support iSCSI Discovery CHAP authentication + * @type {boolean} + * @memberof V1ISCSIVolumeSource + */ + chapAuthDiscovery?: boolean; + /** + * whether support iSCSI Session CHAP authentication + * @type {boolean} + * @memberof V1ISCSIVolumeSource + */ + chapAuthSession?: boolean; + /** + * Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#iscsi + * @type {string} + * @memberof V1ISCSIVolumeSource + */ + fsType?: string; + /** + * Custom iSCSI Initiator Name. If initiatorName is specified with iscsiInterface simultaneously, new iSCSI interface : will be created for the connection. + * @type {string} + * @memberof V1ISCSIVolumeSource + */ + initiatorName?: string; + /** + * Target iSCSI Qualified Name. + * @type {string} + * @memberof V1ISCSIVolumeSource + */ + iqn: string; + /** + * iSCSI Interface Name that uses an iSCSI transport. Defaults to \'default\' (tcp). + * @type {string} + * @memberof V1ISCSIVolumeSource + */ + iscsiInterface?: string; + /** + * iSCSI Target Lun number. + * @type {number} + * @memberof V1ISCSIVolumeSource + */ + lun: number; + /** + * iSCSI Target Portal List. The portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). + * @type {Array} + * @memberof V1ISCSIVolumeSource + */ + portals?: string[]; + /** + * ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. + * @type {boolean} + * @memberof V1ISCSIVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1ISCSIVolumeSource + */ + secretRef?: V1LocalObjectReference; + /** + * iSCSI Target Portal. The Portal is either an IP or ip_addr:port if the port is other than default (typically TCP ports 860 and 3260). + * @type {string} + * @memberof V1ISCSIVolumeSource + */ + targetPortal: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Initializer.ts b/frontend/packages/kube-types/src/openshift/V1Initializer.ts new file mode 100644 index 00000000000..e1887195fd8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Initializer.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Initializer is information about an initializer that has not yet completed. + * @export + * @interface V1Initializer + */ +export interface V1Initializer { + /** + * name of the process that is responsible for initializing this object. + * @type {string} + * @memberof V1Initializer + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Initializers.ts b/frontend/packages/kube-types/src/openshift/V1Initializers.ts new file mode 100644 index 00000000000..014e1593797 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Initializers.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Initializer } from './V1Initializer'; +import { V1Status } from './V1Status'; + +/** + * Initializers tracks the progress of initialization. + * @export + * @interface V1Initializers + */ +export interface V1Initializers { + /** + * Pending is a list of initializers that must execute in order before this object is visible. When the last pending initializer is removed, and no failing result is set, the initializers struct will be set to nil and the object is considered as initialized and visible to all clients. + * @type {Array} + * @memberof V1Initializers + */ + pending: V1Initializer[]; + /** + * + * @type {V1Status} + * @memberof V1Initializers + */ + result?: V1Status; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Job.ts b/frontend/packages/kube-types/src/openshift/V1Job.ts new file mode 100644 index 00000000000..b406e327f80 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Job.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1JobSpec } from './V1JobSpec'; +import { V1JobStatus } from './V1JobStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Job represents the configuration of a single job. + * @export + * @interface V1Job + */ +export interface V1Job { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Job + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Job + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Job + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1JobSpec} + * @memberof V1Job + */ + spec?: V1JobSpec; + /** + * + * @type {V1JobStatus} + * @memberof V1Job + */ + status?: V1JobStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1JobCondition.ts b/frontend/packages/kube-types/src/openshift/V1JobCondition.ts new file mode 100644 index 00000000000..014d8a3e366 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1JobCondition.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * JobCondition describes current state of a job. + * @export + * @interface V1JobCondition + */ +export interface V1JobCondition { + /** + * + * @type {string} + * @memberof V1JobCondition + */ + lastProbeTime?: string; + /** + * + * @type {string} + * @memberof V1JobCondition + */ + lastTransitionTime?: string; + /** + * Human readable message indicating details about last transition. + * @type {string} + * @memberof V1JobCondition + */ + message?: string; + /** + * (brief) reason for the condition\'s last transition. + * @type {string} + * @memberof V1JobCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1JobCondition + */ + status: string; + /** + * Type of job condition, Complete or Failed. + * @type {string} + * @memberof V1JobCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1JobList.ts b/frontend/packages/kube-types/src/openshift/V1JobList.ts new file mode 100644 index 00000000000..006af55fee4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1JobList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Job } from './V1Job'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * JobList is a collection of jobs. + * @export + * @interface V1JobList + */ +export interface V1JobList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1JobList + */ + apiVersion?: string; + /** + * items is the list of Jobs. + * @type {Array} + * @memberof V1JobList + */ + items: V1Job[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1JobList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1JobList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1JobSpec.ts b/frontend/packages/kube-types/src/openshift/V1JobSpec.ts new file mode 100644 index 00000000000..d4270fecf68 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1JobSpec.ts @@ -0,0 +1,65 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * JobSpec describes how the job execution will look like. + * @export + * @interface V1JobSpec + */ +export interface V1JobSpec { + /** + * Specifies the duration in seconds relative to the startTime that the job may be active before the system tries to terminate it; value must be positive integer + * @type {number} + * @memberof V1JobSpec + */ + activeDeadlineSeconds?: number; + /** + * Specifies the number of retries before marking this job failed. Defaults to 6 + * @type {number} + * @memberof V1JobSpec + */ + backoffLimit?: number; + /** + * Specifies the desired number of successfully finished pods the job should be run with. Setting to nil means that the success of any pod signals the success of all pods, and allows parallelism to have any positive value. Setting to 1 means that parallelism is limited to 1 and the success of that pod signals the success of the job. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/ + * @type {number} + * @memberof V1JobSpec + */ + completions?: number; + /** + * manualSelector controls generation of pod labels and pod selectors. Leave `manualSelector` unset unless you are certain what you are doing. When false or unset, the system pick labels unique to this job and appends those labels to the pod template. When true, the user is responsible for picking unique labels and specifying the selector. Failure to pick a unique label may cause this and other jobs to not function correctly. However, You may see `manualSelector=true` in jobs that were created with the old `extensions/v1beta1` API. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/#specifying-your-own-pod-selector + * @type {boolean} + * @memberof V1JobSpec + */ + manualSelector?: boolean; + /** + * Specifies the maximum desired number of pods the job should run at any given time. The actual number of pods running in steady state will be less than this number when ((.spec.completions - .status.successful) < .spec.parallelism), i.e. when the work left to do is less than max parallelism. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/ + * @type {number} + * @memberof V1JobSpec + */ + parallelism?: number; + /** + * + * @type {V1LabelSelector} + * @memberof V1JobSpec + */ + selector?: V1LabelSelector; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1JobSpec + */ + template: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1JobStatus.ts b/frontend/packages/kube-types/src/openshift/V1JobStatus.ts new file mode 100644 index 00000000000..6ebb48b554a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1JobStatus.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1JobCondition } from './V1JobCondition'; + +/** + * JobStatus represents the current state of a Job. + * @export + * @interface V1JobStatus + */ +export interface V1JobStatus { + /** + * The number of actively running pods. + * @type {number} + * @memberof V1JobStatus + */ + active?: number; + /** + * + * @type {string} + * @memberof V1JobStatus + */ + completionTime?: string; + /** + * The latest available observations of an object\'s current state. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/ + * @type {Array} + * @memberof V1JobStatus + */ + conditions?: V1JobCondition[]; + /** + * The number of pods which reached phase Failed. + * @type {number} + * @memberof V1JobStatus + */ + failed?: number; + /** + * + * @type {string} + * @memberof V1JobStatus + */ + startTime?: string; + /** + * The number of pods which reached phase Succeeded. + * @type {number} + * @memberof V1JobStatus + */ + succeeded?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1KeyToPath.ts b/frontend/packages/kube-types/src/openshift/V1KeyToPath.ts new file mode 100644 index 00000000000..badedfde441 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1KeyToPath.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Maps a string key to a path within a volume. + * @export + * @interface V1KeyToPath + */ +export interface V1KeyToPath { + /** + * The key to project. + * @type {string} + * @memberof V1KeyToPath + */ + key: string; + /** + * Optional: mode bits to use on this file, must be a value between 0 and 0777. If not specified, the volume defaultMode will be used. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. + * @type {number} + * @memberof V1KeyToPath + */ + mode?: number; + /** + * The relative path of the file to map the key to. May not be an absolute path. May not contain the path element \'..\'. May not start with the string \'..\'. + * @type {string} + * @memberof V1KeyToPath + */ + path: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1LabelSelector.ts b/frontend/packages/kube-types/src/openshift/V1LabelSelector.ts new file mode 100644 index 00000000000..ac53e11a2d1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1LabelSelector.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelectorRequirement } from './V1LabelSelectorRequirement'; + +/** + * A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects. + * @export + * @interface V1LabelSelector + */ +export interface V1LabelSelector { + /** + * matchExpressions is a list of label selector requirements. The requirements are ANDed. + * @type {Array} + * @memberof V1LabelSelector + */ + matchExpressions?: V1LabelSelectorRequirement[]; + /** + * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed. + * @type {{ [key: string]: string; }} + * @memberof V1LabelSelector + */ + matchLabels?: { [key: string]: string }; +} diff --git a/frontend/packages/kube-types/src/openshift/V1LabelSelectorRequirement.ts b/frontend/packages/kube-types/src/openshift/V1LabelSelectorRequirement.ts new file mode 100644 index 00000000000..0b919c8fecd --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1LabelSelectorRequirement.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + * @export + * @interface V1LabelSelectorRequirement + */ +export interface V1LabelSelectorRequirement { + /** + * key is the label key that the selector applies to. + * @type {string} + * @memberof V1LabelSelectorRequirement + */ + key: string; + /** + * operator represents a key\'s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + * @type {string} + * @memberof V1LabelSelectorRequirement + */ + operator: string; + /** + * values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + * @type {Array} + * @memberof V1LabelSelectorRequirement + */ + values?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Lifecycle.ts b/frontend/packages/kube-types/src/openshift/V1Lifecycle.ts new file mode 100644 index 00000000000..b6132d1f1ab --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Lifecycle.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Handler } from './V1Handler'; + +/** + * Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted. + * @export + * @interface V1Lifecycle + */ +export interface V1Lifecycle { + /** + * + * @type {V1Handler} + * @memberof V1Lifecycle + */ + postStart?: V1Handler; + /** + * + * @type {V1Handler} + * @memberof V1Lifecycle + */ + preStop?: V1Handler; +} diff --git a/frontend/packages/kube-types/src/openshift/V1LimitRange.ts b/frontend/packages/kube-types/src/openshift/V1LimitRange.ts new file mode 100644 index 00000000000..8883a1c5ca1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1LimitRange.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LimitRangeSpec } from './V1LimitRangeSpec'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * LimitRange sets resource usage limits for each kind of resource in a Namespace. + * @export + * @interface V1LimitRange + */ +export interface V1LimitRange { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1LimitRange + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1LimitRange + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1LimitRange + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1LimitRangeSpec} + * @memberof V1LimitRange + */ + spec?: V1LimitRangeSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1LimitRangeItem.ts b/frontend/packages/kube-types/src/openshift/V1LimitRangeItem.ts new file mode 100644 index 00000000000..2e334ca329e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1LimitRangeItem.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * LimitRangeItem defines a min/max usage limit for any resource that matches on kind. + * @export + * @interface V1LimitRangeItem + */ +export interface V1LimitRangeItem { + /** + * Default resource requirement limit value by resource name if resource limit is omitted. + * @type {{ [key: string]: string; }} + * @memberof V1LimitRangeItem + */ + _default?: { [key: string]: string }; + /** + * DefaultRequest is the default resource requirement request value by resource name if resource request is omitted. + * @type {{ [key: string]: string; }} + * @memberof V1LimitRangeItem + */ + defaultRequest?: { [key: string]: string }; + /** + * Max usage constraints on this kind by resource name. + * @type {{ [key: string]: string; }} + * @memberof V1LimitRangeItem + */ + max?: { [key: string]: string }; + /** + * MaxLimitRequestRatio if specified, the named resource must have a request and limit that are both non-zero where limit divided by request is less than or equal to the enumerated value; this represents the max burst for the named resource. + * @type {{ [key: string]: string; }} + * @memberof V1LimitRangeItem + */ + maxLimitRequestRatio?: { [key: string]: string }; + /** + * Min usage constraints on this kind by resource name. + * @type {{ [key: string]: string; }} + * @memberof V1LimitRangeItem + */ + min?: { [key: string]: string }; + /** + * Type of resource that this limit applies to. + * @type {string} + * @memberof V1LimitRangeItem + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1LimitRangeList.ts b/frontend/packages/kube-types/src/openshift/V1LimitRangeList.ts new file mode 100644 index 00000000000..e162f8729d3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1LimitRangeList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LimitRange } from './V1LimitRange'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * LimitRangeList is a list of LimitRange items. + * @export + * @interface V1LimitRangeList + */ +export interface V1LimitRangeList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1LimitRangeList + */ + apiVersion?: string; + /** + * Items is a list of LimitRange objects. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/ + * @type {Array} + * @memberof V1LimitRangeList + */ + items: V1LimitRange[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1LimitRangeList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1LimitRangeList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1LimitRangeSpec.ts b/frontend/packages/kube-types/src/openshift/V1LimitRangeSpec.ts new file mode 100644 index 00000000000..968bc60527a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1LimitRangeSpec.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LimitRangeItem } from './V1LimitRangeItem'; + +/** + * LimitRangeSpec defines a min/max usage limit for resources that match on kind. + * @export + * @interface V1LimitRangeSpec + */ +export interface V1LimitRangeSpec { + /** + * Limits is the list of LimitRangeItem objects that are enforced. + * @type {Array} + * @memberof V1LimitRangeSpec + */ + limits: V1LimitRangeItem[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ListMeta.ts b/frontend/packages/kube-types/src/openshift/V1ListMeta.ts new file mode 100644 index 00000000000..143ad89994a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ListMeta.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}. + * @export + * @interface V1ListMeta + */ +export interface V1ListMeta { + /** + * continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response. + * @type {string} + * @memberof V1ListMeta + */ + _continue?: string; + /** + * String that identifies the server\'s internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency + * @type {string} + * @memberof V1ListMeta + */ + resourceVersion?: string; + /** + * selfLink is a URL representing this object. Populated by the system. Read-only. + * @type {string} + * @memberof V1ListMeta + */ + selfLink?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1LoadBalancerIngress.ts b/frontend/packages/kube-types/src/openshift/V1LoadBalancerIngress.ts new file mode 100644 index 00000000000..ada64b43663 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1LoadBalancerIngress.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * LoadBalancerIngress represents the status of a load-balancer ingress point: traffic intended for the service should be sent to an ingress point. + * @export + * @interface V1LoadBalancerIngress + */ +export interface V1LoadBalancerIngress { + /** + * Hostname is set for load-balancer ingress points that are DNS based (typically AWS load-balancers) + * @type {string} + * @memberof V1LoadBalancerIngress + */ + hostname?: string; + /** + * IP is set for load-balancer ingress points that are IP based (typically GCE or OpenStack load-balancers) + * @type {string} + * @memberof V1LoadBalancerIngress + */ + ip?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1LoadBalancerStatus.ts b/frontend/packages/kube-types/src/openshift/V1LoadBalancerStatus.ts new file mode 100644 index 00000000000..cdb58eb5a7f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1LoadBalancerStatus.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LoadBalancerIngress } from './V1LoadBalancerIngress'; + +/** + * LoadBalancerStatus represents the status of a load-balancer. + * @export + * @interface V1LoadBalancerStatus + */ +export interface V1LoadBalancerStatus { + /** + * Ingress is a list containing ingress points for the load-balancer. Traffic intended for the service should be sent to these ingress points. + * @type {Array} + * @memberof V1LoadBalancerStatus + */ + ingress?: V1LoadBalancerIngress[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1LocalObjectReference.ts b/frontend/packages/kube-types/src/openshift/V1LocalObjectReference.ts new file mode 100644 index 00000000000..2239e302bad --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1LocalObjectReference.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace. + * @export + * @interface V1LocalObjectReference + */ +export interface V1LocalObjectReference { + /** + * Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1LocalObjectReference + */ + name?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1LocalSubjectAccessReview.ts b/frontend/packages/kube-types/src/openshift/V1LocalSubjectAccessReview.ts new file mode 100644 index 00000000000..82d17811b8f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1LocalSubjectAccessReview.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SubjectAccessReviewSpec } from './V1SubjectAccessReviewSpec'; +import { V1SubjectAccessReviewStatus } from './V1SubjectAccessReviewStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * LocalSubjectAccessReview checks whether or not a user or group can perform an action in a given namespace. Having a namespace scoped resource makes it much easier to grant namespace scoped policy that includes permissions checking. + * @export + * @interface V1LocalSubjectAccessReview + */ +export interface V1LocalSubjectAccessReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1LocalSubjectAccessReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1LocalSubjectAccessReview + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1LocalSubjectAccessReview + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1SubjectAccessReviewSpec} + * @memberof V1LocalSubjectAccessReview + */ + spec: V1SubjectAccessReviewSpec; + /** + * + * @type {V1SubjectAccessReviewStatus} + * @memberof V1LocalSubjectAccessReview + */ + status?: V1SubjectAccessReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1LocalVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1LocalVolumeSource.ts new file mode 100644 index 00000000000..1f36f1bcb61 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1LocalVolumeSource.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Local represents directly-attached storage with node affinity (Beta feature) + * @export + * @interface V1LocalVolumeSource + */ +export interface V1LocalVolumeSource { + /** + * The full path to the volume on the node. It can be either a directory or block device (disk, partition, ...). Directories can be represented only by PersistentVolume with VolumeMode=Filesystem. Block devices can be represented only by VolumeMode=Block, which also requires the BlockVolume alpha feature gate to be enabled. + * @type {string} + * @memberof V1LocalVolumeSource + */ + path: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NFSVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1NFSVolumeSource.ts new file mode 100644 index 00000000000..aafbf5e23ee --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NFSVolumeSource.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling. + * @export + * @interface V1NFSVolumeSource + */ +export interface V1NFSVolumeSource { + /** + * Path that is exported by the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs + * @type {string} + * @memberof V1NFSVolumeSource + */ + path: string; + /** + * ReadOnly here will force the NFS export to be mounted with read-only permissions. Defaults to false. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs + * @type {boolean} + * @memberof V1NFSVolumeSource + */ + readOnly?: boolean; + /** + * Server is the hostname or IP address of the NFS server. More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs + * @type {string} + * @memberof V1NFSVolumeSource + */ + server: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Namespace.ts b/frontend/packages/kube-types/src/openshift/V1Namespace.ts new file mode 100644 index 00000000000..eab611d0dad --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Namespace.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NamespaceSpec } from './V1NamespaceSpec'; +import { V1NamespaceStatus } from './V1NamespaceStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Namespace provides a scope for Names. Use of multiple namespaces is optional. + * @export + * @interface V1Namespace + */ +export interface V1Namespace { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Namespace + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Namespace + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Namespace + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1NamespaceSpec} + * @memberof V1Namespace + */ + spec?: V1NamespaceSpec; + /** + * + * @type {V1NamespaceStatus} + * @memberof V1Namespace + */ + status?: V1NamespaceStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NamespaceList.ts b/frontend/packages/kube-types/src/openshift/V1NamespaceList.ts new file mode 100644 index 00000000000..513d8cb5fde --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NamespaceList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Namespace } from './V1Namespace'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * NamespaceList is a list of Namespaces. + * @export + * @interface V1NamespaceList + */ +export interface V1NamespaceList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1NamespaceList + */ + apiVersion?: string; + /** + * Items is the list of Namespace objects in the list. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ + * @type {Array} + * @memberof V1NamespaceList + */ + items: V1Namespace[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1NamespaceList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1NamespaceList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NamespaceSpec.ts b/frontend/packages/kube-types/src/openshift/V1NamespaceSpec.ts new file mode 100644 index 00000000000..2d6fd7d9c18 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NamespaceSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * NamespaceSpec describes the attributes on a Namespace. + * @export + * @interface V1NamespaceSpec + */ +export interface V1NamespaceSpec { + /** + * Finalizers is an opaque list of values that must be empty to permanently remove object from storage. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/ + * @type {Array} + * @memberof V1NamespaceSpec + */ + finalizers?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NamespaceStatus.ts b/frontend/packages/kube-types/src/openshift/V1NamespaceStatus.ts new file mode 100644 index 00000000000..afad706df05 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NamespaceStatus.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * NamespaceStatus is information about the current status of a Namespace. + * @export + * @interface V1NamespaceStatus + */ +export interface V1NamespaceStatus { + /** + * Phase is the current lifecycle phase of the namespace. More info: https://kubernetes.io/docs/tasks/administer-cluster/namespaces/ + * @type {string} + * @memberof V1NamespaceStatus + */ + phase?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NetworkPolicy.ts b/frontend/packages/kube-types/src/openshift/V1NetworkPolicy.ts new file mode 100644 index 00000000000..6526f208d7e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NetworkPolicy.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NetworkPolicySpec } from './V1NetworkPolicySpec'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * NetworkPolicy describes what network traffic is allowed for a set of Pods + * @export + * @interface V1NetworkPolicy + */ +export interface V1NetworkPolicy { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1NetworkPolicy + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1NetworkPolicy + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1NetworkPolicy + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1NetworkPolicySpec} + * @memberof V1NetworkPolicy + */ + spec?: V1NetworkPolicySpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NetworkPolicyEgressRule.ts b/frontend/packages/kube-types/src/openshift/V1NetworkPolicyEgressRule.ts new file mode 100644 index 00000000000..4f7d856f570 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NetworkPolicyEgressRule.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NetworkPolicyPeer } from './V1NetworkPolicyPeer'; +import { V1NetworkPolicyPort } from './V1NetworkPolicyPort'; + +/** + * NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec\'s podSelector. The traffic must match both ports and to. This type is beta-level in 1.8 + * @export + * @interface V1NetworkPolicyEgressRule + */ +export interface V1NetworkPolicyEgressRule { + /** + * List of destination ports for outgoing traffic. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. + * @type {Array} + * @memberof V1NetworkPolicyEgressRule + */ + ports?: V1NetworkPolicyPort[]; + /** + * List of destinations for outgoing traffic of pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all destinations (traffic not restricted by destination). If this field is present and contains at least one item, this rule allows traffic only if the traffic matches at least one item in the to list. + * @type {Array} + * @memberof V1NetworkPolicyEgressRule + */ + to?: V1NetworkPolicyPeer[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NetworkPolicyIngressRule.ts b/frontend/packages/kube-types/src/openshift/V1NetworkPolicyIngressRule.ts new file mode 100644 index 00000000000..07fa2995253 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NetworkPolicyIngressRule.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NetworkPolicyPeer } from './V1NetworkPolicyPeer'; +import { V1NetworkPolicyPort } from './V1NetworkPolicyPort'; + +/** + * NetworkPolicyIngressRule describes a particular set of traffic that is allowed to the pods matched by a NetworkPolicySpec\'s podSelector. The traffic must match both ports and from. + * @export + * @interface V1NetworkPolicyIngressRule + */ +export interface V1NetworkPolicyIngressRule { + /** + * List of sources which should be able to access the pods selected for this rule. Items in this list are combined using a logical OR operation. If this field is empty or missing, this rule matches all sources (traffic not restricted by source). If this field is present and contains at least on item, this rule allows traffic only if the traffic matches at least one item in the from list. + * @type {Array} + * @memberof V1NetworkPolicyIngressRule + */ + from?: V1NetworkPolicyPeer[]; + /** + * List of ports which should be made accessible on the pods selected for this rule. Each item in this list is combined using a logical OR. If this field is empty or missing, this rule matches all ports (traffic not restricted by port). If this field is present and contains at least one item, then this rule allows traffic only if the traffic matches at least one port in the list. + * @type {Array} + * @memberof V1NetworkPolicyIngressRule + */ + ports?: V1NetworkPolicyPort[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NetworkPolicyList.ts b/frontend/packages/kube-types/src/openshift/V1NetworkPolicyList.ts new file mode 100644 index 00000000000..513965c3c33 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NetworkPolicyList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NetworkPolicy } from './V1NetworkPolicy'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * NetworkPolicyList is a list of NetworkPolicy objects. + * @export + * @interface V1NetworkPolicyList + */ +export interface V1NetworkPolicyList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1NetworkPolicyList + */ + apiVersion?: string; + /** + * Items is a list of schema objects. + * @type {Array} + * @memberof V1NetworkPolicyList + */ + items: V1NetworkPolicy[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1NetworkPolicyList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1NetworkPolicyList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NetworkPolicyPeer.ts b/frontend/packages/kube-types/src/openshift/V1NetworkPolicyPeer.ts new file mode 100644 index 00000000000..dea898e53aa --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NetworkPolicyPeer.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1IPBlock } from './V1IPBlock'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * NetworkPolicyPeer describes a peer to allow traffic from. Only certain combinations of fields are allowed + * @export + * @interface V1NetworkPolicyPeer + */ +export interface V1NetworkPolicyPeer { + /** + * + * @type {V1IPBlock} + * @memberof V1NetworkPolicyPeer + */ + ipBlock?: V1IPBlock; + /** + * + * @type {V1LabelSelector} + * @memberof V1NetworkPolicyPeer + */ + namespaceSelector?: V1LabelSelector; + /** + * + * @type {V1LabelSelector} + * @memberof V1NetworkPolicyPeer + */ + podSelector?: V1LabelSelector; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NetworkPolicyPort.ts b/frontend/packages/kube-types/src/openshift/V1NetworkPolicyPort.ts new file mode 100644 index 00000000000..def3ce45da4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NetworkPolicyPort.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * NetworkPolicyPort describes a port to allow traffic on + * @export + * @interface V1NetworkPolicyPort + */ +export interface V1NetworkPolicyPort { + /** + * + * @type {string} + * @memberof V1NetworkPolicyPort + */ + port?: string; + /** + * The protocol (TCP or UDP) which traffic must match. If not specified, this field defaults to TCP. + * @type {string} + * @memberof V1NetworkPolicyPort + */ + protocol?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NetworkPolicySpec.ts b/frontend/packages/kube-types/src/openshift/V1NetworkPolicySpec.ts new file mode 100644 index 00000000000..a2e0bc98862 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NetworkPolicySpec.ts @@ -0,0 +1,48 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NetworkPolicyEgressRule } from './V1NetworkPolicyEgressRule'; +import { V1NetworkPolicyIngressRule } from './V1NetworkPolicyIngressRule'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * NetworkPolicySpec provides the specification of a NetworkPolicy + * @export + * @interface V1NetworkPolicySpec + */ +export interface V1NetworkPolicySpec { + /** + * List of egress rules to be applied to the selected pods. Outgoing traffic is allowed if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic matches at least one egress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy limits all outgoing traffic (and serves solely to ensure that the pods it selects are isolated by default). This field is beta-level in 1.8 + * @type {Array} + * @memberof V1NetworkPolicySpec + */ + egress?: V1NetworkPolicyEgressRule[]; + /** + * List of ingress rules to be applied to the selected pods. Traffic is allowed to a pod if there are no NetworkPolicies selecting the pod (and cluster policy otherwise allows the traffic), OR if the traffic source is the pod\'s local node, OR if the traffic matches at least one ingress rule across all of the NetworkPolicy objects whose podSelector matches the pod. If this field is empty then this NetworkPolicy does not allow any traffic (and serves solely to ensure that the pods it selects are isolated by default) + * @type {Array} + * @memberof V1NetworkPolicySpec + */ + ingress?: V1NetworkPolicyIngressRule[]; + /** + * + * @type {V1LabelSelector} + * @memberof V1NetworkPolicySpec + */ + podSelector: V1LabelSelector; + /** + * List of rule types that the NetworkPolicy relates to. Valid options are Ingress, Egress, or Ingress,Egress. If this field is not specified, it will default based on the existence of Ingress or Egress rules; policies that contain an Egress section are assumed to affect Egress, and all policies (whether or not they contain an Ingress section) are assumed to affect Ingress. If you want to write an egress-only policy, you must explicitly specify policyTypes [ \"Egress\" ]. Likewise, if you want to write a policy that specifies that no egress is allowed, you must specify a policyTypes value that include \"Egress\" (since such a policy would not include an Egress section and would otherwise default to just [ \"Ingress\" ]). This field is beta-level in 1.8 + * @type {Array} + * @memberof V1NetworkPolicySpec + */ + policyTypes?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Node.ts b/frontend/packages/kube-types/src/openshift/V1Node.ts new file mode 100644 index 00000000000..b3842c61e1d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Node.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeSpec } from './V1NodeSpec'; +import { V1NodeStatus } from './V1NodeStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Node is a worker node in Kubernetes. Each node will have a unique identifier in the cache (i.e. in etcd). + * @export + * @interface V1Node + */ +export interface V1Node { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Node + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Node + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Node + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1NodeSpec} + * @memberof V1Node + */ + spec?: V1NodeSpec; + /** + * + * @type {V1NodeStatus} + * @memberof V1Node + */ + status?: V1NodeStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeAddress.ts b/frontend/packages/kube-types/src/openshift/V1NodeAddress.ts new file mode 100644 index 00000000000..bca177d952b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeAddress.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * NodeAddress contains information for the node\'s address. + * @export + * @interface V1NodeAddress + */ +export interface V1NodeAddress { + /** + * The node address. + * @type {string} + * @memberof V1NodeAddress + */ + address: string; + /** + * Node address type, one of Hostname, ExternalIP or InternalIP. + * @type {string} + * @memberof V1NodeAddress + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeAffinity.ts b/frontend/packages/kube-types/src/openshift/V1NodeAffinity.ts new file mode 100644 index 00000000000..f84811f90bd --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeAffinity.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeSelector } from './V1NodeSelector'; +import { V1PreferredSchedulingTerm } from './V1PreferredSchedulingTerm'; + +/** + * Node affinity is a group of node affinity scheduling rules. + * @export + * @interface V1NodeAffinity + */ +export interface V1NodeAffinity { + /** + * The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred. + * @type {Array} + * @memberof V1NodeAffinity + */ + preferredDuringSchedulingIgnoredDuringExecution?: V1PreferredSchedulingTerm[]; + /** + * + * @type {V1NodeSelector} + * @memberof V1NodeAffinity + */ + requiredDuringSchedulingIgnoredDuringExecution?: V1NodeSelector; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeCondition.ts b/frontend/packages/kube-types/src/openshift/V1NodeCondition.ts new file mode 100644 index 00000000000..dc1653de8dc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeCondition.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * NodeCondition contains condition information for a node. + * @export + * @interface V1NodeCondition + */ +export interface V1NodeCondition { + /** + * + * @type {string} + * @memberof V1NodeCondition + */ + lastHeartbeatTime?: string; + /** + * + * @type {string} + * @memberof V1NodeCondition + */ + lastTransitionTime?: string; + /** + * Human readable message indicating details about last transition. + * @type {string} + * @memberof V1NodeCondition + */ + message?: string; + /** + * (brief) reason for the condition\'s last transition. + * @type {string} + * @memberof V1NodeCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1NodeCondition + */ + status: string; + /** + * Type of node condition. + * @type {string} + * @memberof V1NodeCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeConfigSource.ts b/frontend/packages/kube-types/src/openshift/V1NodeConfigSource.ts new file mode 100644 index 00000000000..5d430c7346f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeConfigSource.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ConfigMapNodeConfigSource } from './V1ConfigMapNodeConfigSource'; + +/** + * NodeConfigSource specifies a source of node configuration. Exactly one subfield (excluding metadata) must be non-nil. + * @export + * @interface V1NodeConfigSource + */ +export interface V1NodeConfigSource { + /** + * + * @type {V1ConfigMapNodeConfigSource} + * @memberof V1NodeConfigSource + */ + configMap?: V1ConfigMapNodeConfigSource; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeConfigStatus.ts b/frontend/packages/kube-types/src/openshift/V1NodeConfigStatus.ts new file mode 100644 index 00000000000..36a540baa7b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeConfigStatus.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeConfigSource } from './V1NodeConfigSource'; + +/** + * NodeConfigStatus describes the status of the config assigned by Node.Spec.ConfigSource. + * @export + * @interface V1NodeConfigStatus + */ +export interface V1NodeConfigStatus { + /** + * + * @type {V1NodeConfigSource} + * @memberof V1NodeConfigStatus + */ + active?: V1NodeConfigSource; + /** + * + * @type {V1NodeConfigSource} + * @memberof V1NodeConfigStatus + */ + assigned?: V1NodeConfigSource; + /** + * Error describes any problems reconciling the Spec.ConfigSource to the Active config. Errors may occur, for example, attempting to checkpoint Spec.ConfigSource to the local Assigned record, attempting to checkpoint the payload associated with Spec.ConfigSource, attempting to load or validate the Assigned config, etc. Errors may occur at different points while syncing config. Earlier errors (e.g. download or checkpointing errors) will not result in a rollback to LastKnownGood, and may resolve across Kubelet retries. Later errors (e.g. loading or validating a checkpointed config) will result in a rollback to LastKnownGood. In the latter case, it is usually possible to resolve the error by fixing the config assigned in Spec.ConfigSource. You can find additional information for debugging by searching the error message in the Kubelet log. Error is a human-readable description of the error state; machines can check whether or not Error is empty, but should not rely on the stability of the Error text across Kubelet versions. + * @type {string} + * @memberof V1NodeConfigStatus + */ + error?: string; + /** + * + * @type {V1NodeConfigSource} + * @memberof V1NodeConfigStatus + */ + lastKnownGood?: V1NodeConfigSource; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeDaemonEndpoints.ts b/frontend/packages/kube-types/src/openshift/V1NodeDaemonEndpoints.ts new file mode 100644 index 00000000000..88abc122250 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeDaemonEndpoints.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DaemonEndpoint } from './V1DaemonEndpoint'; + +/** + * NodeDaemonEndpoints lists ports opened by daemons running on the Node. + * @export + * @interface V1NodeDaemonEndpoints + */ +export interface V1NodeDaemonEndpoints { + /** + * + * @type {V1DaemonEndpoint} + * @memberof V1NodeDaemonEndpoints + */ + kubeletEndpoint?: V1DaemonEndpoint; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeList.ts b/frontend/packages/kube-types/src/openshift/V1NodeList.ts new file mode 100644 index 00000000000..9fed5e9ee04 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Node } from './V1Node'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * NodeList is the whole list of all Nodes which have been registered with master. + * @export + * @interface V1NodeList + */ +export interface V1NodeList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1NodeList + */ + apiVersion?: string; + /** + * List of nodes + * @type {Array} + * @memberof V1NodeList + */ + items: V1Node[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1NodeList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1NodeList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeSelector.ts b/frontend/packages/kube-types/src/openshift/V1NodeSelector.ts new file mode 100644 index 00000000000..6b3d917a696 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeSelector.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeSelectorTerm } from './V1NodeSelectorTerm'; + +/** + * A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms. + * @export + * @interface V1NodeSelector + */ +export interface V1NodeSelector { + /** + * Required. A list of node selector terms. The terms are ORed. + * @type {Array} + * @memberof V1NodeSelector + */ + nodeSelectorTerms: V1NodeSelectorTerm[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeSelectorRequirement.ts b/frontend/packages/kube-types/src/openshift/V1NodeSelectorRequirement.ts new file mode 100644 index 00000000000..6e3c3d9b21b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeSelectorRequirement.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + * @export + * @interface V1NodeSelectorRequirement + */ +export interface V1NodeSelectorRequirement { + /** + * The label key that the selector applies to. + * @type {string} + * @memberof V1NodeSelectorRequirement + */ + key: string; + /** + * Represents a key\'s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + * @type {string} + * @memberof V1NodeSelectorRequirement + */ + operator: string; + /** + * An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + * @type {Array} + * @memberof V1NodeSelectorRequirement + */ + values?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeSelectorTerm.ts b/frontend/packages/kube-types/src/openshift/V1NodeSelectorTerm.ts new file mode 100644 index 00000000000..482f2f83999 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeSelectorTerm.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeSelectorRequirement } from './V1NodeSelectorRequirement'; + +/** + * A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm. + * @export + * @interface V1NodeSelectorTerm + */ +export interface V1NodeSelectorTerm { + /** + * A list of node selector requirements by node\'s labels. + * @type {Array} + * @memberof V1NodeSelectorTerm + */ + matchExpressions?: V1NodeSelectorRequirement[]; + /** + * A list of node selector requirements by node\'s fields. + * @type {Array} + * @memberof V1NodeSelectorTerm + */ + matchFields?: V1NodeSelectorRequirement[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeSpec.ts b/frontend/packages/kube-types/src/openshift/V1NodeSpec.ts new file mode 100644 index 00000000000..a67170ddcab --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeSpec.ts @@ -0,0 +1,59 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeConfigSource } from './V1NodeConfigSource'; +import { V1Taint } from './V1Taint'; + +/** + * NodeSpec describes the attributes that a node is created with. + * @export + * @interface V1NodeSpec + */ +export interface V1NodeSpec { + /** + * + * @type {V1NodeConfigSource} + * @memberof V1NodeSpec + */ + configSource?: V1NodeConfigSource; + /** + * Deprecated. Not all kubelets will set this field. Remove field after 1.13. see: https://issues.k8s.io/61966 + * @type {string} + * @memberof V1NodeSpec + */ + externalID?: string; + /** + * PodCIDR represents the pod IP range assigned to the node. + * @type {string} + * @memberof V1NodeSpec + */ + podCIDR?: string; + /** + * ID of the node assigned by the cloud provider in the format: :// + * @type {string} + * @memberof V1NodeSpec + */ + providerID?: string; + /** + * If specified, the node\'s taints. + * @type {Array} + * @memberof V1NodeSpec + */ + taints?: V1Taint[]; + /** + * Unschedulable controls node schedulability of new pods. By default, node is schedulable. More info: https://kubernetes.io/docs/concepts/nodes/node/#manual-node-administration + * @type {boolean} + * @memberof V1NodeSpec + */ + unschedulable?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeStatus.ts b/frontend/packages/kube-types/src/openshift/V1NodeStatus.ts new file mode 100644 index 00000000000..ca0e0e6497c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeStatus.ts @@ -0,0 +1,94 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1AttachedVolume } from './V1AttachedVolume'; +import { V1ContainerImage } from './V1ContainerImage'; +import { V1NodeAddress } from './V1NodeAddress'; +import { V1NodeCondition } from './V1NodeCondition'; +import { V1NodeConfigStatus } from './V1NodeConfigStatus'; +import { V1NodeDaemonEndpoints } from './V1NodeDaemonEndpoints'; +import { V1NodeSystemInfo } from './V1NodeSystemInfo'; + +/** + * NodeStatus is information about the current status of a node. + * @export + * @interface V1NodeStatus + */ +export interface V1NodeStatus { + /** + * List of addresses reachable to the node. Queried from cloud provider, if available. More info: https://kubernetes.io/docs/concepts/nodes/node/#addresses + * @type {Array} + * @memberof V1NodeStatus + */ + addresses?: V1NodeAddress[]; + /** + * Allocatable represents the resources of a node that are available for scheduling. Defaults to Capacity. + * @type {{ [key: string]: string; }} + * @memberof V1NodeStatus + */ + allocatable?: { [key: string]: string }; + /** + * Capacity represents the total resources of a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity + * @type {{ [key: string]: string; }} + * @memberof V1NodeStatus + */ + capacity?: { [key: string]: string }; + /** + * Conditions is an array of current observed node conditions. More info: https://kubernetes.io/docs/concepts/nodes/node/#condition + * @type {Array} + * @memberof V1NodeStatus + */ + conditions?: V1NodeCondition[]; + /** + * + * @type {V1NodeConfigStatus} + * @memberof V1NodeStatus + */ + config?: V1NodeConfigStatus; + /** + * + * @type {V1NodeDaemonEndpoints} + * @memberof V1NodeStatus + */ + daemonEndpoints?: V1NodeDaemonEndpoints; + /** + * List of container images on this node + * @type {Array} + * @memberof V1NodeStatus + */ + images?: V1ContainerImage[]; + /** + * + * @type {V1NodeSystemInfo} + * @memberof V1NodeStatus + */ + nodeInfo?: V1NodeSystemInfo; + /** + * NodePhase is the recently observed lifecycle phase of the node. More info: https://kubernetes.io/docs/concepts/nodes/node/#phase The field is never populated, and now is deprecated. + * @type {string} + * @memberof V1NodeStatus + */ + phase?: string; + /** + * List of volumes that are attached to the node. + * @type {Array} + * @memberof V1NodeStatus + */ + volumesAttached?: V1AttachedVolume[]; + /** + * List of attachable volumes in use (mounted) by the node. + * @type {Array} + * @memberof V1NodeStatus + */ + volumesInUse?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NodeSystemInfo.ts b/frontend/packages/kube-types/src/openshift/V1NodeSystemInfo.ts new file mode 100644 index 00000000000..65f04014de6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NodeSystemInfo.ts @@ -0,0 +1,80 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * NodeSystemInfo is a set of ids/uuids to uniquely identify the node. + * @export + * @interface V1NodeSystemInfo + */ +export interface V1NodeSystemInfo { + /** + * The Architecture reported by the node + * @type {string} + * @memberof V1NodeSystemInfo + */ + architecture: string; + /** + * Boot ID reported by the node. + * @type {string} + * @memberof V1NodeSystemInfo + */ + bootID: string; + /** + * ContainerRuntime Version reported by the node through runtime remote API (e.g. docker://1.5.0). + * @type {string} + * @memberof V1NodeSystemInfo + */ + containerRuntimeVersion: string; + /** + * Kernel Version reported by the node from \'uname -r\' (e.g. 3.16.0-0.bpo.4-amd64). + * @type {string} + * @memberof V1NodeSystemInfo + */ + kernelVersion: string; + /** + * KubeProxy Version reported by the node. + * @type {string} + * @memberof V1NodeSystemInfo + */ + kubeProxyVersion: string; + /** + * Kubelet Version reported by the node. + * @type {string} + * @memberof V1NodeSystemInfo + */ + kubeletVersion: string; + /** + * MachineID reported by the node. For unique machine identification in the cluster this field is preferred. Learn more from man(5) machine-id: http://man7.org/linux/man-pages/man5/machine-id.5.html + * @type {string} + * @memberof V1NodeSystemInfo + */ + machineID: string; + /** + * The Operating System reported by the node + * @type {string} + * @memberof V1NodeSystemInfo + */ + operatingSystem: string; + /** + * OS Image reported by the node from /etc/os-release (e.g. Debian GNU/Linux 7 (wheezy)). + * @type {string} + * @memberof V1NodeSystemInfo + */ + osImage: string; + /** + * SystemUUID reported by the node. For unique machine identification MachineID is preferred. This field is specific to Red Hat hosts https://access.redhat.com/documentation/en-US/Red_Hat_Subscription_Management/1/html/RHSM/getting-system-uuid.html + * @type {string} + * @memberof V1NodeSystemInfo + */ + systemUUID: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NonResourceAttributes.ts b/frontend/packages/kube-types/src/openshift/V1NonResourceAttributes.ts new file mode 100644 index 00000000000..41ea138e37e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NonResourceAttributes.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * NonResourceAttributes includes the authorization attributes available for non-resource requests to the Authorizer interface + * @export + * @interface V1NonResourceAttributes + */ +export interface V1NonResourceAttributes { + /** + * Path is the URL path of the request + * @type {string} + * @memberof V1NonResourceAttributes + */ + path?: string; + /** + * Verb is the standard HTTP verb + * @type {string} + * @memberof V1NonResourceAttributes + */ + verb?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1NonResourceRule.ts b/frontend/packages/kube-types/src/openshift/V1NonResourceRule.ts new file mode 100644 index 00000000000..feab59d1c42 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1NonResourceRule.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * NonResourceRule holds information that describes a rule for the non-resource + * @export + * @interface V1NonResourceRule + */ +export interface V1NonResourceRule { + /** + * NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path. \"*\" means all. + * @type {Array} + * @memberof V1NonResourceRule + */ + nonResourceURLs?: string[]; + /** + * Verb is a list of kubernetes non-resource API verbs, like: get, post, put, delete, patch, head, options. \"*\" means all. + * @type {Array} + * @memberof V1NonResourceRule + */ + verbs: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ObjectFieldSelector.ts b/frontend/packages/kube-types/src/openshift/V1ObjectFieldSelector.ts new file mode 100644 index 00000000000..2b2d1c6bce0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ObjectFieldSelector.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ObjectFieldSelector selects an APIVersioned field of an object. + * @export + * @interface V1ObjectFieldSelector + */ +export interface V1ObjectFieldSelector { + /** + * Version of the schema the FieldPath is written in terms of, defaults to \"v1\". + * @type {string} + * @memberof V1ObjectFieldSelector + */ + apiVersion?: string; + /** + * Path of the field to select in the specified API version. + * @type {string} + * @memberof V1ObjectFieldSelector + */ + fieldPath: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ObjectMeta.ts b/frontend/packages/kube-types/src/openshift/V1ObjectMeta.ts new file mode 100644 index 00000000000..33437889357 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ObjectMeta.ts @@ -0,0 +1,119 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Initializers } from './V1Initializers'; +import { V1OwnerReference } from './V1OwnerReference'; + +/** + * ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create. + * @export + * @interface V1ObjectMeta + */ +export interface V1ObjectMeta { + /** + * Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations + * @type {{ [key: string]: string; }} + * @memberof V1ObjectMeta + */ + annotations?: { [key: string]: string }; + /** + * The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request. + * @type {string} + * @memberof V1ObjectMeta + */ + clusterName?: string; + /** + * + * @type {string} + * @memberof V1ObjectMeta + */ + creationTimestamp?: string; + /** + * Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only. + * @type {number} + * @memberof V1ObjectMeta + */ + deletionGracePeriodSeconds?: number; + /** + * + * @type {string} + * @memberof V1ObjectMeta + */ + deletionTimestamp?: string; + /** + * Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. + * @type {Array} + * @memberof V1ObjectMeta + */ + finalizers?: string[]; + /** + * GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server. If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header). Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#idempotency + * @type {string} + * @memberof V1ObjectMeta + */ + generateName?: string; + /** + * A sequence number representing a specific generation of the desired state. Populated by the system. Read-only. + * @type {number} + * @memberof V1ObjectMeta + */ + generation?: number; + /** + * + * @type {V1Initializers} + * @memberof V1ObjectMeta + */ + initializers?: V1Initializers; + /** + * Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels + * @type {{ [key: string]: string; }} + * @memberof V1ObjectMeta + */ + labels?: { [key: string]: string }; + /** + * Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names + * @type {string} + * @memberof V1ObjectMeta + */ + name?: string; + /** + * Namespace defines the space within each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces + * @type {string} + * @memberof V1ObjectMeta + */ + namespace?: string; + /** + * List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller. + * @type {Array} + * @memberof V1ObjectMeta + */ + ownerReferences?: V1OwnerReference[]; + /** + * An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources. Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency + * @type {string} + * @memberof V1ObjectMeta + */ + resourceVersion?: string; + /** + * SelfLink is a URL representing this object. Populated by the system. Read-only. + * @type {string} + * @memberof V1ObjectMeta + */ + selfLink?: string; + /** + * UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations. Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids + * @type {string} + * @memberof V1ObjectMeta + */ + uid?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ObjectReference.ts b/frontend/packages/kube-types/src/openshift/V1ObjectReference.ts new file mode 100644 index 00000000000..9fe5658ab1c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ObjectReference.ts @@ -0,0 +1,62 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ObjectReference contains enough information to let you inspect or modify the referred object. + * @export + * @interface V1ObjectReference + */ +export interface V1ObjectReference { + /** + * API version of the referent. + * @type {string} + * @memberof V1ObjectReference + */ + apiVersion?: string; + /** + * If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: \"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered the event) or if no container name is specified \"spec.containers[2]\" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object. + * @type {string} + * @memberof V1ObjectReference + */ + fieldPath?: string; + /** + * Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ObjectReference + */ + kind?: string; + /** + * Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1ObjectReference + */ + name?: string; + /** + * Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ + * @type {string} + * @memberof V1ObjectReference + */ + namespace?: string; + /** + * Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency + * @type {string} + * @memberof V1ObjectReference + */ + resourceVersion?: string; + /** + * UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids + * @type {string} + * @memberof V1ObjectReference + */ + uid?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1OwnerReference.ts b/frontend/packages/kube-types/src/openshift/V1OwnerReference.ts new file mode 100644 index 00000000000..7ade0ec1a73 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1OwnerReference.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * OwnerReference contains enough information to let you identify an owning object. Currently, an owning object must be in the same namespace, so there is no namespace field. + * @export + * @interface V1OwnerReference + */ +export interface V1OwnerReference { + /** + * API version of the referent. + * @type {string} + * @memberof V1OwnerReference + */ + apiVersion: string; + /** + * If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned. + * @type {boolean} + * @memberof V1OwnerReference + */ + blockOwnerDeletion?: boolean; + /** + * If true, this reference points to the managing controller. + * @type {boolean} + * @memberof V1OwnerReference + */ + controller?: boolean; + /** + * Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1OwnerReference + */ + kind: string; + /** + * Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names + * @type {string} + * @memberof V1OwnerReference + */ + name: string; + /** + * UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids + * @type {string} + * @memberof V1OwnerReference + */ + uid: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Parameter.ts b/frontend/packages/kube-types/src/openshift/V1Parameter.ts new file mode 100644 index 00000000000..fd29368c0a2 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Parameter.ts @@ -0,0 +1,62 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Parameter defines a name/value variable that is to be processed during the Template to Config transformation. + * @export + * @interface V1Parameter + */ +export interface V1Parameter { + /** + * Description of a parameter. Optional. + * @type {string} + * @memberof V1Parameter + */ + description?: string; + /** + * Optional: The name that will show in UI instead of parameter \'Name\' + * @type {string} + * @memberof V1Parameter + */ + displayName?: string; + /** + * From is an input value for the generator. Optional. + * @type {string} + * @memberof V1Parameter + */ + from?: string; + /** + * generate specifies the generator to be used to generate random string from an input value specified by From field. The result string is stored into Value field. If empty, no generator is being used, leaving the result Value untouched. Optional. The only supported generator is \"expression\", which accepts a \"from\" value in the form of a simple regular expression containing the range expression \"[a-zA-Z0-9]\", and the length expression \"a{length}\". Examples: from | value ----------------------------- \"test[0-9]{1}x\" | \"test7x\" \"[0-1]{8}\" | \"01001100\" \"0x[A-F0-9]{4}\" | \"0xB3AF\" \"[a-zA-Z0-9]{8}\" | \"hW4yQU5i\" + * @type {string} + * @memberof V1Parameter + */ + generate?: string; + /** + * Name must be set and it can be referenced in Template Items using ${PARAMETER_NAME}. Required. + * @type {string} + * @memberof V1Parameter + */ + name: string; + /** + * Optional: Indicates the parameter must have a value. Defaults to false. + * @type {boolean} + * @memberof V1Parameter + */ + required?: boolean; + /** + * Value holds the Parameter data. If specified, the generator will be ignored. The value replaces all occurrences of the Parameter ${Name} expression during the Template to Config transformation. Optional. + * @type {string} + * @memberof V1Parameter + */ + value?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PersistentVolume.ts b/frontend/packages/kube-types/src/openshift/V1PersistentVolume.ts new file mode 100644 index 00000000000..79b5390bb6e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PersistentVolume.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PersistentVolumeSpec } from './V1PersistentVolumeSpec'; +import { V1PersistentVolumeStatus } from './V1PersistentVolumeStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * PersistentVolume (PV) is a storage resource provisioned by an administrator. It is analogous to a node. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes + * @export + * @interface V1PersistentVolume + */ +export interface V1PersistentVolume { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1PersistentVolume + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1PersistentVolume + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1PersistentVolume + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1PersistentVolumeSpec} + * @memberof V1PersistentVolume + */ + spec?: V1PersistentVolumeSpec; + /** + * + * @type {V1PersistentVolumeStatus} + * @memberof V1PersistentVolume + */ + status?: V1PersistentVolumeStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaim.ts b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaim.ts new file mode 100644 index 00000000000..59d9c441fa7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaim.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PersistentVolumeClaimSpec } from './V1PersistentVolumeClaimSpec'; +import { V1PersistentVolumeClaimStatus } from './V1PersistentVolumeClaimStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * PersistentVolumeClaim is a user\'s request for and claim to a persistent volume + * @export + * @interface V1PersistentVolumeClaim + */ +export interface V1PersistentVolumeClaim { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1PersistentVolumeClaim + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1PersistentVolumeClaim + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1PersistentVolumeClaim + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1PersistentVolumeClaimSpec} + * @memberof V1PersistentVolumeClaim + */ + spec?: V1PersistentVolumeClaimSpec; + /** + * + * @type {V1PersistentVolumeClaimStatus} + * @memberof V1PersistentVolumeClaim + */ + status?: V1PersistentVolumeClaimStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimCondition.ts b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimCondition.ts new file mode 100644 index 00000000000..dd67bc6e426 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimCondition.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PersistentVolumeClaimCondition contails details about state of pvc + * @export + * @interface V1PersistentVolumeClaimCondition + */ +export interface V1PersistentVolumeClaimCondition { + /** + * + * @type {string} + * @memberof V1PersistentVolumeClaimCondition + */ + lastProbeTime?: string; + /** + * + * @type {string} + * @memberof V1PersistentVolumeClaimCondition + */ + lastTransitionTime?: string; + /** + * Human-readable message indicating details about last transition. + * @type {string} + * @memberof V1PersistentVolumeClaimCondition + */ + message?: string; + /** + * Unique, this should be a short, machine understandable string that gives the reason for condition\'s last transition. If it reports \"ResizeStarted\" that means the underlying persistent volume is being resized. + * @type {string} + * @memberof V1PersistentVolumeClaimCondition + */ + reason?: string; + /** + * + * @type {string} + * @memberof V1PersistentVolumeClaimCondition + */ + status: string; + /** + * + * @type {string} + * @memberof V1PersistentVolumeClaimCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimList.ts b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimList.ts new file mode 100644 index 00000000000..2f8ab7d5bb7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PersistentVolumeClaim } from './V1PersistentVolumeClaim'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * PersistentVolumeClaimList is a list of PersistentVolumeClaim items. + * @export + * @interface V1PersistentVolumeClaimList + */ +export interface V1PersistentVolumeClaimList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1PersistentVolumeClaimList + */ + apiVersion?: string; + /** + * A list of persistent volume claims. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims + * @type {Array} + * @memberof V1PersistentVolumeClaimList + */ + items: V1PersistentVolumeClaim[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1PersistentVolumeClaimList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1PersistentVolumeClaimList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimSpec.ts b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimSpec.ts new file mode 100644 index 00000000000..bebc9ec2d55 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimSpec.ts @@ -0,0 +1,59 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ResourceRequirements } from './V1ResourceRequirements'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes + * @export + * @interface V1PersistentVolumeClaimSpec + */ +export interface V1PersistentVolumeClaimSpec { + /** + * AccessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 + * @type {Array} + * @memberof V1PersistentVolumeClaimSpec + */ + accessModes?: string[]; + /** + * + * @type {V1ResourceRequirements} + * @memberof V1PersistentVolumeClaimSpec + */ + resources?: V1ResourceRequirements; + /** + * + * @type {V1LabelSelector} + * @memberof V1PersistentVolumeClaimSpec + */ + selector?: V1LabelSelector; + /** + * Name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1 + * @type {string} + * @memberof V1PersistentVolumeClaimSpec + */ + storageClassName?: string; + /** + * volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec. This is an alpha feature and may change in the future. + * @type {string} + * @memberof V1PersistentVolumeClaimSpec + */ + volumeMode?: string; + /** + * VolumeName is the binding reference to the PersistentVolume backing this claim. + * @type {string} + * @memberof V1PersistentVolumeClaimSpec + */ + volumeName?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimStatus.ts b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimStatus.ts new file mode 100644 index 00000000000..39e69997519 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimStatus.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PersistentVolumeClaimCondition } from './V1PersistentVolumeClaimCondition'; + +/** + * PersistentVolumeClaimStatus is the current status of a persistent volume claim. + * @export + * @interface V1PersistentVolumeClaimStatus + */ +export interface V1PersistentVolumeClaimStatus { + /** + * AccessModes contains the actual access modes the volume backing the PVC has. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 + * @type {Array} + * @memberof V1PersistentVolumeClaimStatus + */ + accessModes?: string[]; + /** + * Represents the actual resources of the underlying volume. + * @type {{ [key: string]: string; }} + * @memberof V1PersistentVolumeClaimStatus + */ + capacity?: { [key: string]: string }; + /** + * Current Condition of persistent volume claim. If underlying persistent volume is being resized then the Condition will be set to \'ResizeStarted\'. + * @type {Array} + * @memberof V1PersistentVolumeClaimStatus + */ + conditions?: V1PersistentVolumeClaimCondition[]; + /** + * Phase represents the current phase of PersistentVolumeClaim. + * @type {string} + * @memberof V1PersistentVolumeClaimStatus + */ + phase?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimVolumeSource.ts new file mode 100644 index 00000000000..55c3f5c6b9e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeClaimVolumeSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PersistentVolumeClaimVolumeSource references the user\'s PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system). + * @export + * @interface V1PersistentVolumeClaimVolumeSource + */ +export interface V1PersistentVolumeClaimVolumeSource { + /** + * ClaimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims + * @type {string} + * @memberof V1PersistentVolumeClaimVolumeSource + */ + claimName: string; + /** + * Will force the ReadOnly setting in VolumeMounts. Default false. + * @type {boolean} + * @memberof V1PersistentVolumeClaimVolumeSource + */ + readOnly?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PersistentVolumeList.ts b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeList.ts new file mode 100644 index 00000000000..0ed537fe40e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PersistentVolume } from './V1PersistentVolume'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * PersistentVolumeList is a list of PersistentVolume items. + * @export + * @interface V1PersistentVolumeList + */ +export interface V1PersistentVolumeList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1PersistentVolumeList + */ + apiVersion?: string; + /** + * List of persistent volumes. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes + * @type {Array} + * @memberof V1PersistentVolumeList + */ + items: V1PersistentVolume[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1PersistentVolumeList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1PersistentVolumeList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PersistentVolumeSpec.ts b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeSpec.ts new file mode 100644 index 00000000000..f58966982d7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeSpec.ts @@ -0,0 +1,225 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1AWSElasticBlockStoreVolumeSource } from './V1AWSElasticBlockStoreVolumeSource'; +import { V1AzureDiskVolumeSource } from './V1AzureDiskVolumeSource'; +import { V1AzureFilePersistentVolumeSource } from './V1AzureFilePersistentVolumeSource'; +import { V1CSIPersistentVolumeSource } from './V1CSIPersistentVolumeSource'; +import { V1CephFSPersistentVolumeSource } from './V1CephFSPersistentVolumeSource'; +import { V1CinderPersistentVolumeSource } from './V1CinderPersistentVolumeSource'; +import { V1FCVolumeSource } from './V1FCVolumeSource'; +import { V1FlexPersistentVolumeSource } from './V1FlexPersistentVolumeSource'; +import { V1FlockerVolumeSource } from './V1FlockerVolumeSource'; +import { V1GCEPersistentDiskVolumeSource } from './V1GCEPersistentDiskVolumeSource'; +import { V1GlusterfsVolumeSource } from './V1GlusterfsVolumeSource'; +import { V1HostPathVolumeSource } from './V1HostPathVolumeSource'; +import { V1ISCSIPersistentVolumeSource } from './V1ISCSIPersistentVolumeSource'; +import { V1LocalVolumeSource } from './V1LocalVolumeSource'; +import { V1NFSVolumeSource } from './V1NFSVolumeSource'; +import { V1ObjectReference } from './V1ObjectReference'; +import { V1PhotonPersistentDiskVolumeSource } from './V1PhotonPersistentDiskVolumeSource'; +import { V1PortworxVolumeSource } from './V1PortworxVolumeSource'; +import { V1QuobyteVolumeSource } from './V1QuobyteVolumeSource'; +import { V1RBDPersistentVolumeSource } from './V1RBDPersistentVolumeSource'; +import { V1ScaleIOPersistentVolumeSource } from './V1ScaleIOPersistentVolumeSource'; +import { V1StorageOSPersistentVolumeSource } from './V1StorageOSPersistentVolumeSource'; +import { V1VolumeNodeAffinity } from './V1VolumeNodeAffinity'; +import { V1VsphereVirtualDiskVolumeSource } from './V1VsphereVirtualDiskVolumeSource'; + +/** + * PersistentVolumeSpec is the specification of a persistent volume. + * @export + * @interface V1PersistentVolumeSpec + */ +export interface V1PersistentVolumeSpec { + /** + * AccessModes contains all ways the volume can be mounted. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes + * @type {Array} + * @memberof V1PersistentVolumeSpec + */ + accessModes?: string[]; + /** + * + * @type {V1AWSElasticBlockStoreVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + awsElasticBlockStore?: V1AWSElasticBlockStoreVolumeSource; + /** + * + * @type {V1AzureDiskVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + azureDisk?: V1AzureDiskVolumeSource; + /** + * + * @type {V1AzureFilePersistentVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + azureFile?: V1AzureFilePersistentVolumeSource; + /** + * A description of the persistent volume\'s resources and capacity. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity + * @type {{ [key: string]: string; }} + * @memberof V1PersistentVolumeSpec + */ + capacity?: { [key: string]: string }; + /** + * + * @type {V1CephFSPersistentVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + cephfs?: V1CephFSPersistentVolumeSource; + /** + * + * @type {V1CinderPersistentVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + cinder?: V1CinderPersistentVolumeSource; + /** + * + * @type {V1ObjectReference} + * @memberof V1PersistentVolumeSpec + */ + claimRef?: V1ObjectReference; + /** + * + * @type {V1CSIPersistentVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + csi?: V1CSIPersistentVolumeSource; + /** + * + * @type {V1FCVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + fc?: V1FCVolumeSource; + /** + * + * @type {V1FlexPersistentVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + flexVolume?: V1FlexPersistentVolumeSource; + /** + * + * @type {V1FlockerVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + flocker?: V1FlockerVolumeSource; + /** + * + * @type {V1GCEPersistentDiskVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + gcePersistentDisk?: V1GCEPersistentDiskVolumeSource; + /** + * + * @type {V1GlusterfsVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + glusterfs?: V1GlusterfsVolumeSource; + /** + * + * @type {V1HostPathVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + hostPath?: V1HostPathVolumeSource; + /** + * + * @type {V1ISCSIPersistentVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + iscsi?: V1ISCSIPersistentVolumeSource; + /** + * + * @type {V1LocalVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + local?: V1LocalVolumeSource; + /** + * A list of mount options, e.g. [\"ro\", \"soft\"]. Not validated - mount will simply fail if one is invalid. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options + * @type {Array} + * @memberof V1PersistentVolumeSpec + */ + mountOptions?: string[]; + /** + * + * @type {V1NFSVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + nfs?: V1NFSVolumeSource; + /** + * + * @type {V1VolumeNodeAffinity} + * @memberof V1PersistentVolumeSpec + */ + nodeAffinity?: V1VolumeNodeAffinity; + /** + * What happens to a persistent volume when released from its claim. Valid options are Retain (default for manually created PersistentVolumes), Delete (default for dynamically provisioned PersistentVolumes), and Recycle (deprecated). Recycle must be supported by the volume plugin underlying this PersistentVolume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming + * @type {string} + * @memberof V1PersistentVolumeSpec + */ + persistentVolumeReclaimPolicy?: string; + /** + * + * @type {V1PhotonPersistentDiskVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + photonPersistentDisk?: V1PhotonPersistentDiskVolumeSource; + /** + * + * @type {V1PortworxVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + portworxVolume?: V1PortworxVolumeSource; + /** + * + * @type {V1QuobyteVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + quobyte?: V1QuobyteVolumeSource; + /** + * + * @type {V1RBDPersistentVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + rbd?: V1RBDPersistentVolumeSource; + /** + * + * @type {V1ScaleIOPersistentVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + scaleIO?: V1ScaleIOPersistentVolumeSource; + /** + * Name of StorageClass to which this persistent volume belongs. Empty value means that this volume does not belong to any StorageClass. + * @type {string} + * @memberof V1PersistentVolumeSpec + */ + storageClassName?: string; + /** + * + * @type {V1StorageOSPersistentVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + storageos?: V1StorageOSPersistentVolumeSource; + /** + * volumeMode defines if a volume is intended to be used with a formatted filesystem or to remain in raw block state. Value of Filesystem is implied when not included in spec. This is an alpha feature and may change in the future. + * @type {string} + * @memberof V1PersistentVolumeSpec + */ + volumeMode?: string; + /** + * + * @type {V1VsphereVirtualDiskVolumeSource} + * @memberof V1PersistentVolumeSpec + */ + vsphereVolume?: V1VsphereVirtualDiskVolumeSource; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PersistentVolumeStatus.ts b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeStatus.ts new file mode 100644 index 00000000000..ca2e1eeed36 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PersistentVolumeStatus.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PersistentVolumeStatus is the current status of a persistent volume. + * @export + * @interface V1PersistentVolumeStatus + */ +export interface V1PersistentVolumeStatus { + /** + * A human-readable message indicating details about why the volume is in this state. + * @type {string} + * @memberof V1PersistentVolumeStatus + */ + message?: string; + /** + * Phase indicates if a volume is available, bound to a claim, or released by a claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#phase + * @type {string} + * @memberof V1PersistentVolumeStatus + */ + phase?: string; + /** + * Reason is a brief CamelCase string that describes any failure and is meant for machine parsing and tidy display in the CLI. + * @type {string} + * @memberof V1PersistentVolumeStatus + */ + reason?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PhotonPersistentDiskVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1PhotonPersistentDiskVolumeSource.ts new file mode 100644 index 00000000000..c9ea96d2942 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PhotonPersistentDiskVolumeSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a Photon Controller persistent disk resource. + * @export + * @interface V1PhotonPersistentDiskVolumeSource + */ +export interface V1PhotonPersistentDiskVolumeSource { + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. + * @type {string} + * @memberof V1PhotonPersistentDiskVolumeSource + */ + fsType?: string; + /** + * ID that identifies Photon Controller persistent disk + * @type {string} + * @memberof V1PhotonPersistentDiskVolumeSource + */ + pdID: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Pod.ts b/frontend/packages/kube-types/src/openshift/V1Pod.ts new file mode 100644 index 00000000000..213014f72f1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Pod.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodSpec } from './V1PodSpec'; +import { V1PodStatus } from './V1PodStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts. + * @export + * @interface V1Pod + */ +export interface V1Pod { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Pod + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Pod + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Pod + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1PodSpec} + * @memberof V1Pod + */ + spec?: V1PodSpec; + /** + * + * @type {V1PodStatus} + * @memberof V1Pod + */ + status?: V1PodStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodAffinity.ts b/frontend/packages/kube-types/src/openshift/V1PodAffinity.ts new file mode 100644 index 00000000000..e42c4a7df67 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodAffinity.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodAffinityTerm } from './V1PodAffinityTerm'; +import { V1WeightedPodAffinityTerm } from './V1WeightedPodAffinityTerm'; + +/** + * Pod affinity is a group of inter pod affinity scheduling rules. + * @export + * @interface V1PodAffinity + */ +export interface V1PodAffinity { + /** + * The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + * @type {Array} + * @memberof V1PodAffinity + */ + preferredDuringSchedulingIgnoredDuringExecution?: V1WeightedPodAffinityTerm[]; + /** + * If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + * @type {Array} + * @memberof V1PodAffinity + */ + requiredDuringSchedulingIgnoredDuringExecution?: V1PodAffinityTerm[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodAffinityTerm.ts b/frontend/packages/kube-types/src/openshift/V1PodAffinityTerm.ts new file mode 100644 index 00000000000..7ee99cda669 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodAffinityTerm.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running + * @export + * @interface V1PodAffinityTerm + */ +export interface V1PodAffinityTerm { + /** + * + * @type {V1LabelSelector} + * @memberof V1PodAffinityTerm + */ + labelSelector?: V1LabelSelector; + /** + * namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means \"this pod\'s namespace\" + * @type {Array} + * @memberof V1PodAffinityTerm + */ + namespaces?: string[]; + /** + * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + * @type {string} + * @memberof V1PodAffinityTerm + */ + topologyKey: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodAntiAffinity.ts b/frontend/packages/kube-types/src/openshift/V1PodAntiAffinity.ts new file mode 100644 index 00000000000..ba80b2d102f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodAntiAffinity.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodAffinityTerm } from './V1PodAffinityTerm'; +import { V1WeightedPodAffinityTerm } from './V1WeightedPodAffinityTerm'; + +/** + * Pod anti affinity is a group of inter pod anti affinity scheduling rules. + * @export + * @interface V1PodAntiAffinity + */ +export interface V1PodAntiAffinity { + /** + * The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + * @type {Array} + * @memberof V1PodAntiAffinity + */ + preferredDuringSchedulingIgnoredDuringExecution?: V1WeightedPodAffinityTerm[]; + /** + * If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + * @type {Array} + * @memberof V1PodAntiAffinity + */ + requiredDuringSchedulingIgnoredDuringExecution?: V1PodAffinityTerm[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodCondition.ts b/frontend/packages/kube-types/src/openshift/V1PodCondition.ts new file mode 100644 index 00000000000..37335bbf2ce --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodCondition.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PodCondition contains details for the current condition of this pod. + * @export + * @interface V1PodCondition + */ +export interface V1PodCondition { + /** + * + * @type {string} + * @memberof V1PodCondition + */ + lastProbeTime?: string; + /** + * + * @type {string} + * @memberof V1PodCondition + */ + lastTransitionTime?: string; + /** + * Human-readable message indicating details about last transition. + * @type {string} + * @memberof V1PodCondition + */ + message?: string; + /** + * Unique, one-word, CamelCase reason for the condition\'s last transition. + * @type {string} + * @memberof V1PodCondition + */ + reason?: string; + /** + * Status is the status of the condition. Can be True, False, Unknown. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions + * @type {string} + * @memberof V1PodCondition + */ + status: string; + /** + * Type is the type of the condition. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions + * @type {string} + * @memberof V1PodCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodDNSConfig.ts b/frontend/packages/kube-types/src/openshift/V1PodDNSConfig.ts new file mode 100644 index 00000000000..7fa0c87b17a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodDNSConfig.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodDNSConfigOption } from './V1PodDNSConfigOption'; + +/** + * PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy. + * @export + * @interface V1PodDNSConfig + */ +export interface V1PodDNSConfig { + /** + * A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed. + * @type {Array} + * @memberof V1PodDNSConfig + */ + nameservers?: string[]; + /** + * A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy. + * @type {Array} + * @memberof V1PodDNSConfig + */ + options?: V1PodDNSConfigOption[]; + /** + * A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed. + * @type {Array} + * @memberof V1PodDNSConfig + */ + searches?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodDNSConfigOption.ts b/frontend/packages/kube-types/src/openshift/V1PodDNSConfigOption.ts new file mode 100644 index 00000000000..d5c19972ed4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodDNSConfigOption.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PodDNSConfigOption defines DNS resolver options of a pod. + * @export + * @interface V1PodDNSConfigOption + */ +export interface V1PodDNSConfigOption { + /** + * Required. + * @type {string} + * @memberof V1PodDNSConfigOption + */ + name?: string; + /** + * + * @type {string} + * @memberof V1PodDNSConfigOption + */ + value?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodList.ts b/frontend/packages/kube-types/src/openshift/V1PodList.ts new file mode 100644 index 00000000000..991aa1a5048 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Pod } from './V1Pod'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * PodList is a list of Pods. + * @export + * @interface V1PodList + */ +export interface V1PodList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1PodList + */ + apiVersion?: string; + /** + * List of pods. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md + * @type {Array} + * @memberof V1PodList + */ + items: V1Pod[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1PodList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1PodList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodReadinessGate.ts b/frontend/packages/kube-types/src/openshift/V1PodReadinessGate.ts new file mode 100644 index 00000000000..e05b99d3352 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodReadinessGate.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PodReadinessGate contains the reference to a pod condition + * @export + * @interface V1PodReadinessGate + */ +export interface V1PodReadinessGate { + /** + * ConditionType refers to a condition in the pod\'s condition list with matching type. + * @type {string} + * @memberof V1PodReadinessGate + */ + conditionType: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodSecurityContext.ts b/frontend/packages/kube-types/src/openshift/V1PodSecurityContext.ts new file mode 100644 index 00000000000..0473d3a6757 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodSecurityContext.ts @@ -0,0 +1,65 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SELinuxOptions } from './V1SELinuxOptions'; +import { V1Sysctl } from './V1Sysctl'; + +/** + * PodSecurityContext holds pod-level security attributes and common container settings. Some fields are also present in container.securityContext. Field values of container.securityContext take precedence over field values of PodSecurityContext. + * @export + * @interface V1PodSecurityContext + */ +export interface V1PodSecurityContext { + /** + * A special supplemental group that applies to all containers in a pod. Some volume types allow the Kubelet to change the ownership of that volume to be owned by the pod: 1. The owning GID will be the FSGroup 2. The setgid bit is set (new files created in the volume will be owned by FSGroup) 3. The permission bits are OR\'d with rw-rw---- If unset, the Kubelet will not modify the ownership and permissions of any volume. + * @type {number} + * @memberof V1PodSecurityContext + */ + fsGroup?: number; + /** + * The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. + * @type {number} + * @memberof V1PodSecurityContext + */ + runAsGroup?: number; + /** + * Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + * @type {boolean} + * @memberof V1PodSecurityContext + */ + runAsNonRoot?: boolean; + /** + * The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence for that container. + * @type {number} + * @memberof V1PodSecurityContext + */ + runAsUser?: number; + /** + * + * @type {V1SELinuxOptions} + * @memberof V1PodSecurityContext + */ + seLinuxOptions?: V1SELinuxOptions; + /** + * A list of groups applied to the first process run in each container, in addition to the container\'s primary GID. If unspecified, no groups will be added to any container. + * @type {Array} + * @memberof V1PodSecurityContext + */ + supplementalGroups?: number[]; + /** + * Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. + * @type {Array} + * @memberof V1PodSecurityContext + */ + sysctls?: V1Sysctl[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodSpec.ts b/frontend/packages/kube-types/src/openshift/V1PodSpec.ts new file mode 100644 index 00000000000..4e8ded95b69 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodSpec.ts @@ -0,0 +1,198 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Affinity } from './V1Affinity'; +import { V1Container } from './V1Container'; +import { V1HostAlias } from './V1HostAlias'; +import { V1LocalObjectReference } from './V1LocalObjectReference'; +import { V1PodDNSConfig } from './V1PodDNSConfig'; +import { V1PodReadinessGate } from './V1PodReadinessGate'; +import { V1PodSecurityContext } from './V1PodSecurityContext'; +import { V1Toleration } from './V1Toleration'; +import { V1Volume } from './V1Volume'; + +/** + * PodSpec is a description of a pod. + * @export + * @interface V1PodSpec + */ +export interface V1PodSpec { + /** + * Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer. + * @type {number} + * @memberof V1PodSpec + */ + activeDeadlineSeconds?: number; + /** + * + * @type {V1Affinity} + * @memberof V1PodSpec + */ + affinity?: V1Affinity; + /** + * AutomountServiceAccountToken indicates whether a service account token should be automatically mounted. + * @type {boolean} + * @memberof V1PodSpec + */ + automountServiceAccountToken?: boolean; + /** + * List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated. + * @type {Array} + * @memberof V1PodSpec + */ + containers: V1Container[]; + /** + * + * @type {V1PodDNSConfig} + * @memberof V1PodSpec + */ + dnsConfig?: V1PodDNSConfig; + /** + * Set DNS policy for the pod. Defaults to \"ClusterFirst\". Valid values are \'ClusterFirstWithHostNet\', \'ClusterFirst\', \'Default\' or \'None\'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to \'ClusterFirstWithHostNet\'. + * @type {string} + * @memberof V1PodSpec + */ + dnsPolicy?: string; + /** + * HostAliases is an optional list of hosts and IPs that will be injected into the pod\'s hosts file if specified. This is only valid for non-hostNetwork pods. + * @type {Array} + * @memberof V1PodSpec + */ + hostAliases?: V1HostAlias[]; + /** + * Use the host\'s ipc namespace. Optional: Default to false. + * @type {boolean} + * @memberof V1PodSpec + */ + hostIPC?: boolean; + /** + * Host networking requested for this pod. Use the host\'s network namespace. If this option is set, the ports that will be used must be specified. Default to false. + * @type {boolean} + * @memberof V1PodSpec + */ + hostNetwork?: boolean; + /** + * Use the host\'s pid namespace. Optional: Default to false. + * @type {boolean} + * @memberof V1PodSpec + */ + hostPID?: boolean; + /** + * Specifies the hostname of the Pod If not specified, the pod\'s hostname will be set to a system-defined value. + * @type {string} + * @memberof V1PodSpec + */ + hostname?: string; + /** + * ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. For example, in the case of docker, only DockerConfig type secrets are honored. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod + * @type {Array} + * @memberof V1PodSpec + */ + imagePullSecrets?: V1LocalObjectReference[]; + /** + * List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, or Liveness probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/ + * @type {Array} + * @memberof V1PodSpec + */ + initContainers?: V1Container[]; + /** + * NodeName is a request to schedule this pod onto a specific node. If it is non-empty, the scheduler simply schedules this pod onto that node, assuming that it fits resource requirements. + * @type {string} + * @memberof V1PodSpec + */ + nodeName?: string; + /** + * NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node\'s labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/ + * @type {{ [key: string]: string; }} + * @memberof V1PodSpec + */ + nodeSelector?: { [key: string]: string }; + /** + * The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority. + * @type {number} + * @memberof V1PodSpec + */ + priority?: number; + /** + * If specified, indicates the pod\'s priority. \"system-node-critical\" and \"system-cluster-critical\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default. + * @type {string} + * @memberof V1PodSpec + */ + priorityClassName?: string; + /** + * If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \"True\" More info: https://github.com/kubernetes/community/blob/master/keps/sig-network/0007-pod-ready%2B%2B.md + * @type {Array} + * @memberof V1PodSpec + */ + readinessGates?: V1PodReadinessGate[]; + /** + * Restart policy for all containers within the pod. One of Always, OnFailure, Never. Default to Always. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy + * @type {string} + * @memberof V1PodSpec + */ + restartPolicy?: string; + /** + * If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler. + * @type {string} + * @memberof V1PodSpec + */ + schedulerName?: string; + /** + * + * @type {V1PodSecurityContext} + * @memberof V1PodSpec + */ + securityContext?: V1PodSecurityContext; + /** + * DeprecatedServiceAccount is a depreciated alias for ServiceAccountName. Deprecated: Use serviceAccountName instead. + * @type {string} + * @memberof V1PodSpec + */ + serviceAccount?: string; + /** + * ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/ + * @type {string} + * @memberof V1PodSpec + */ + serviceAccountName?: string; + /** + * Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false. This field is alpha-level and is honored only by servers that enable the PodShareProcessNamespace feature. + * @type {boolean} + * @memberof V1PodSpec + */ + shareProcessNamespace?: boolean; + /** + * If specified, the fully qualified Pod hostname will be \"...svc.\". If not specified, the pod will not have a domainname at all. + * @type {string} + * @memberof V1PodSpec + */ + subdomain?: string; + /** + * Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds. + * @type {number} + * @memberof V1PodSpec + */ + terminationGracePeriodSeconds?: number; + /** + * If specified, the pod\'s tolerations. + * @type {Array} + * @memberof V1PodSpec + */ + tolerations?: V1Toleration[]; + /** + * List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes + * @type {Array} + * @memberof V1PodSpec + */ + volumes?: V1Volume[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodStatus.ts b/frontend/packages/kube-types/src/openshift/V1PodStatus.ts new file mode 100644 index 00000000000..16d00401f8c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodStatus.ts @@ -0,0 +1,89 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ContainerStatus } from './V1ContainerStatus'; +import { V1PodCondition } from './V1PodCondition'; + +/** + * PodStatus represents information about the status of a pod. Status may trail the actual state of a system, especially if the node that hosts the pod cannot contact the control plane. + * @export + * @interface V1PodStatus + */ +export interface V1PodStatus { + /** + * Current service state of pod. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions + * @type {Array} + * @memberof V1PodStatus + */ + conditions?: V1PodCondition[]; + /** + * The list has one entry per container in the manifest. Each entry is currently the output of `docker inspect`. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status + * @type {Array} + * @memberof V1PodStatus + */ + containerStatuses?: V1ContainerStatus[]; + /** + * IP address of the host to which the pod is assigned. Empty if not yet scheduled. + * @type {string} + * @memberof V1PodStatus + */ + hostIP?: string; + /** + * The list has one entry per init container in the manifest. The most recent successful init container will have ready = true, the most recently started container will have startTime set. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status + * @type {Array} + * @memberof V1PodStatus + */ + initContainerStatuses?: V1ContainerStatus[]; + /** + * A human readable message indicating details about why the pod is in this condition. + * @type {string} + * @memberof V1PodStatus + */ + message?: string; + /** + * nominatedNodeName is set only when this pod preempts other pods on the node, but it cannot be scheduled right away as preemption victims receive their graceful termination periods. This field does not guarantee that the pod will be scheduled on this node. Scheduler may decide to place the pod elsewhere if other nodes become available sooner. Scheduler may also decide to give the resources on this node to a higher priority pod that is created after preemption. As a result, this field may be different than PodSpec.nodeName when the pod is scheduled. + * @type {string} + * @memberof V1PodStatus + */ + nominatedNodeName?: string; + /** + * The phase of a Pod is a simple, high-level summary of where the Pod is in its lifecycle. The conditions array, the reason and message fields, and the individual container status arrays contain more detail about the pod\'s status. There are five possible phase values: Pending: The pod has been accepted by the Kubernetes system, but one or more of the container images has not been created. This includes time before being scheduled as well as time spent downloading images over the network, which could take a while. Running: The pod has been bound to a node, and all of the containers have been created. At least one container is still running, or is in the process of starting or restarting. Succeeded: All containers in the pod have terminated in success, and will not be restarted. Failed: All containers in the pod have terminated, and at least one container has terminated in failure. The container either exited with non-zero status or was terminated by the system. Unknown: For some reason the state of the pod could not be obtained, typically due to an error in communicating with the host of the pod. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-phase + * @type {string} + * @memberof V1PodStatus + */ + phase?: string; + /** + * IP address allocated to the pod. Routable at least within the cluster. Empty if not yet allocated. + * @type {string} + * @memberof V1PodStatus + */ + podIP?: string; + /** + * The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://git.k8s.io/community/contributors/design-proposals/node/resource-qos.md + * @type {string} + * @memberof V1PodStatus + */ + qosClass?: string; + /** + * A brief CamelCase message indicating details about why the pod is in this state. e.g. \'Evicted\' + * @type {string} + * @memberof V1PodStatus + */ + reason?: string; + /** + * + * @type {string} + * @memberof V1PodStatus + */ + startTime?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodTemplate.ts b/frontend/packages/kube-types/src/openshift/V1PodTemplate.ts new file mode 100644 index 00000000000..53f8253ad4e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodTemplate.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * PodTemplate describes a template for creating copies of a predefined pod. + * @export + * @interface V1PodTemplate + */ +export interface V1PodTemplate { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1PodTemplate + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1PodTemplate + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1PodTemplate + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1PodTemplate + */ + template?: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodTemplateList.ts b/frontend/packages/kube-types/src/openshift/V1PodTemplateList.ts new file mode 100644 index 00000000000..3485b8a5ae8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodTemplateList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplate } from './V1PodTemplate'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * PodTemplateList is a list of PodTemplates. + * @export + * @interface V1PodTemplateList + */ +export interface V1PodTemplateList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1PodTemplateList + */ + apiVersion?: string; + /** + * List of pod templates + * @type {Array} + * @memberof V1PodTemplateList + */ + items: V1PodTemplate[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1PodTemplateList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1PodTemplateList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PodTemplateSpec.ts b/frontend/packages/kube-types/src/openshift/V1PodTemplateSpec.ts new file mode 100644 index 00000000000..4c7d56c86e2 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PodTemplateSpec.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodSpec } from './V1PodSpec'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * PodTemplateSpec describes the data a pod should have when created from a template + * @export + * @interface V1PodTemplateSpec + */ +export interface V1PodTemplateSpec { + /** + * + * @type {V1ObjectMeta} + * @memberof V1PodTemplateSpec + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1PodSpec} + * @memberof V1PodTemplateSpec + */ + spec?: V1PodSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PolicyRule.ts b/frontend/packages/kube-types/src/openshift/V1PolicyRule.ts new file mode 100644 index 00000000000..67d20ddf17d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PolicyRule.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. + * @export + * @interface V1PolicyRule + */ +export interface V1PolicyRule { + /** + * APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. + * @type {Array} + * @memberof V1PolicyRule + */ + apiGroups?: string[]; + /** + * NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding. Rules can either apply to API resources (such as \"pods\" or \"secrets\") or non-resource URL paths (such as \"/api\"), but not both. + * @type {Array} + * @memberof V1PolicyRule + */ + nonResourceURLs?: string[]; + /** + * ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. + * @type {Array} + * @memberof V1PolicyRule + */ + resourceNames?: string[]; + /** + * Resources is a list of resources this rule applies to. ResourceAll represents all resources. + * @type {Array} + * @memberof V1PolicyRule + */ + resources?: string[]; + /** + * Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. VerbAll represents all kinds. + * @type {Array} + * @memberof V1PolicyRule + */ + verbs: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PortworxVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1PortworxVolumeSource.ts new file mode 100644 index 00000000000..a4da989570f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PortworxVolumeSource.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PortworxVolumeSource represents a Portworx volume resource. + * @export + * @interface V1PortworxVolumeSource + */ +export interface V1PortworxVolumeSource { + /** + * FSType represents the filesystem type to mount Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\". Implicitly inferred to be \"ext4\" if unspecified. + * @type {string} + * @memberof V1PortworxVolumeSource + */ + fsType?: string; + /** + * Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. + * @type {boolean} + * @memberof V1PortworxVolumeSource + */ + readOnly?: boolean; + /** + * VolumeID uniquely identifies a Portworx volume + * @type {string} + * @memberof V1PortworxVolumeSource + */ + volumeID: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Preconditions.ts b/frontend/packages/kube-types/src/openshift/V1Preconditions.ts new file mode 100644 index 00000000000..9a1d916ae5c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Preconditions.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out. + * @export + * @interface V1Preconditions + */ +export interface V1Preconditions { + /** + * Specifies the target UID. + * @type {string} + * @memberof V1Preconditions + */ + uid?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1PreferredSchedulingTerm.ts b/frontend/packages/kube-types/src/openshift/V1PreferredSchedulingTerm.ts new file mode 100644 index 00000000000..e8b6bf023d4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1PreferredSchedulingTerm.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeSelectorTerm } from './V1NodeSelectorTerm'; + +/** + * An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it\'s a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). + * @export + * @interface V1PreferredSchedulingTerm + */ +export interface V1PreferredSchedulingTerm { + /** + * + * @type {V1NodeSelectorTerm} + * @memberof V1PreferredSchedulingTerm + */ + preference: V1NodeSelectorTerm; + /** + * Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. + * @type {number} + * @memberof V1PreferredSchedulingTerm + */ + weight: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Probe.ts b/frontend/packages/kube-types/src/openshift/V1Probe.ts new file mode 100644 index 00000000000..fafd9dd1ae8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Probe.ts @@ -0,0 +1,72 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ExecAction } from './V1ExecAction'; +import { V1HTTPGetAction } from './V1HTTPGetAction'; +import { V1TCPSocketAction } from './V1TCPSocketAction'; + +/** + * Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic. + * @export + * @interface V1Probe + */ +export interface V1Probe { + /** + * + * @type {V1ExecAction} + * @memberof V1Probe + */ + exec?: V1ExecAction; + /** + * Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. + * @type {number} + * @memberof V1Probe + */ + failureThreshold?: number; + /** + * + * @type {V1HTTPGetAction} + * @memberof V1Probe + */ + httpGet?: V1HTTPGetAction; + /** + * Number of seconds after the container has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes + * @type {number} + * @memberof V1Probe + */ + initialDelaySeconds?: number; + /** + * How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. + * @type {number} + * @memberof V1Probe + */ + periodSeconds?: number; + /** + * Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness. Minimum value is 1. + * @type {number} + * @memberof V1Probe + */ + successThreshold?: number; + /** + * + * @type {V1TCPSocketAction} + * @memberof V1Probe + */ + tcpSocket?: V1TCPSocketAction; + /** + * Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes + * @type {number} + * @memberof V1Probe + */ + timeoutSeconds?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Project.ts b/frontend/packages/kube-types/src/openshift/V1Project.ts new file mode 100644 index 00000000000..4293a91028b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Project.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ProjectSpec } from './V1ProjectSpec'; +import { V1ProjectStatus } from './V1ProjectStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Projects are the unit of isolation and collaboration in OpenShift. A project has one or more members, a quota on the resources that the project may consume, and the security controls on the resources in the project. Within a project, members may have different roles - project administrators can set membership, editors can create and manage the resources, and viewers can see but not access running containers. In a normal cluster project administrators are not able to alter their quotas - that is restricted to cluster administrators. Listing or watching projects will return only projects the user has the reader role on. An OpenShift project is an alternative representation of a Kubernetes namespace. Projects are exposed as editable to end users while namespaces are not. Direct creation of a project is typically restricted to administrators, while end users should use the requestproject resource. + * @export + * @interface V1Project + */ +export interface V1Project { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Project + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Project + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Project + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1ProjectSpec} + * @memberof V1Project + */ + spec?: V1ProjectSpec; + /** + * + * @type {V1ProjectStatus} + * @memberof V1Project + */ + status?: V1ProjectStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ProjectList.ts b/frontend/packages/kube-types/src/openshift/V1ProjectList.ts new file mode 100644 index 00000000000..9efbe8d1e0c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ProjectList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Project } from './V1Project'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ProjectList is a list of Project objects. + * @export + * @interface V1ProjectList + */ +export interface V1ProjectList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ProjectList + */ + apiVersion?: string; + /** + * Items is the list of projects + * @type {Array} + * @memberof V1ProjectList + */ + items: V1Project[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ProjectList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1ProjectList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ProjectRequest.ts b/frontend/packages/kube-types/src/openshift/V1ProjectRequest.ts new file mode 100644 index 00000000000..ca8cd31a089 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ProjectRequest.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ProjecRequest is the set of options necessary to fully qualify a project request + * @export + * @interface V1ProjectRequest + */ +export interface V1ProjectRequest { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ProjectRequest + */ + apiVersion?: string; + /** + * Description is the description to apply to a project + * @type {string} + * @memberof V1ProjectRequest + */ + description?: string; + /** + * DisplayName is the display name to apply to a project + * @type {string} + * @memberof V1ProjectRequest + */ + displayName?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ProjectRequest + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1ProjectRequest + */ + metadata?: V1ObjectMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ProjectSpec.ts b/frontend/packages/kube-types/src/openshift/V1ProjectSpec.ts new file mode 100644 index 00000000000..2694a6c433e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ProjectSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ProjectSpec describes the attributes on a Project + * @export + * @interface V1ProjectSpec + */ +export interface V1ProjectSpec { + /** + * Finalizers is an opaque list of values that must be empty to permanently remove object from storage + * @type {Array} + * @memberof V1ProjectSpec + */ + finalizers?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ProjectStatus.ts b/frontend/packages/kube-types/src/openshift/V1ProjectStatus.ts new file mode 100644 index 00000000000..d35e588d97a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ProjectStatus.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ProjectStatus is information about the current status of a Project + * @export + * @interface V1ProjectStatus + */ +export interface V1ProjectStatus { + /** + * Phase is the current lifecycle phase of the project + * @type {string} + * @memberof V1ProjectStatus + */ + phase?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ProjectedVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1ProjectedVolumeSource.ts new file mode 100644 index 00000000000..cb64860dce3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ProjectedVolumeSource.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1VolumeProjection } from './V1VolumeProjection'; + +/** + * Represents a projected volume source + * @export + * @interface V1ProjectedVolumeSource + */ +export interface V1ProjectedVolumeSource { + /** + * Mode bits to use on created files by default. Must be a value between 0 and 0777. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. + * @type {number} + * @memberof V1ProjectedVolumeSource + */ + defaultMode?: number; + /** + * list of volume projections + * @type {Array} + * @memberof V1ProjectedVolumeSource + */ + sources: V1VolumeProjection[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1QuobyteVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1QuobyteVolumeSource.ts new file mode 100644 index 00000000000..db970d2d211 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1QuobyteVolumeSource.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling. + * @export + * @interface V1QuobyteVolumeSource + */ +export interface V1QuobyteVolumeSource { + /** + * Group to map volume access to Default is no group + * @type {string} + * @memberof V1QuobyteVolumeSource + */ + group?: string; + /** + * ReadOnly here will force the Quobyte volume to be mounted with read-only permissions. Defaults to false. + * @type {boolean} + * @memberof V1QuobyteVolumeSource + */ + readOnly?: boolean; + /** + * Registry represents a single or multiple Quobyte Registry services specified as a string as host:port pair (multiple entries are separated with commas) which acts as the central registry for volumes + * @type {string} + * @memberof V1QuobyteVolumeSource + */ + registry: string; + /** + * User to map volume access to Defaults to serivceaccount user + * @type {string} + * @memberof V1QuobyteVolumeSource + */ + user?: string; + /** + * Volume is a string that references an already created Quobyte volume by name. + * @type {string} + * @memberof V1QuobyteVolumeSource + */ + volume: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RBDPersistentVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1RBDPersistentVolumeSource.ts new file mode 100644 index 00000000000..ec52b7cabf1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RBDPersistentVolumeSource.ts @@ -0,0 +1,70 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SecretReference } from './V1SecretReference'; + +/** + * Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling. + * @export + * @interface V1RBDPersistentVolumeSource + */ +export interface V1RBDPersistentVolumeSource { + /** + * Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd + * @type {string} + * @memberof V1RBDPersistentVolumeSource + */ + fsType?: string; + /** + * The rados image name. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {string} + * @memberof V1RBDPersistentVolumeSource + */ + image: string; + /** + * Keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {string} + * @memberof V1RBDPersistentVolumeSource + */ + keyring?: string; + /** + * A collection of Ceph monitors. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {Array} + * @memberof V1RBDPersistentVolumeSource + */ + monitors: string[]; + /** + * The rados pool name. Default is rbd. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {string} + * @memberof V1RBDPersistentVolumeSource + */ + pool?: string; + /** + * ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {boolean} + * @memberof V1RBDPersistentVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1SecretReference} + * @memberof V1RBDPersistentVolumeSource + */ + secretRef?: V1SecretReference; + /** + * The rados user name. Default is admin. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {string} + * @memberof V1RBDPersistentVolumeSource + */ + user?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RBDVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1RBDVolumeSource.ts new file mode 100644 index 00000000000..2e08cd33b25 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RBDVolumeSource.ts @@ -0,0 +1,70 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling. + * @export + * @interface V1RBDVolumeSource + */ +export interface V1RBDVolumeSource { + /** + * Filesystem type of the volume that you want to mount. Tip: Ensure that the filesystem type is supported by the host operating system. Examples: \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. More info: https://kubernetes.io/docs/concepts/storage/volumes#rbd + * @type {string} + * @memberof V1RBDVolumeSource + */ + fsType?: string; + /** + * The rados image name. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {string} + * @memberof V1RBDVolumeSource + */ + image: string; + /** + * Keyring is the path to key ring for RBDUser. Default is /etc/ceph/keyring. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {string} + * @memberof V1RBDVolumeSource + */ + keyring?: string; + /** + * A collection of Ceph monitors. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {Array} + * @memberof V1RBDVolumeSource + */ + monitors: string[]; + /** + * The rados pool name. Default is rbd. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {string} + * @memberof V1RBDVolumeSource + */ + pool?: string; + /** + * ReadOnly here will force the ReadOnly setting in VolumeMounts. Defaults to false. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {boolean} + * @memberof V1RBDVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1RBDVolumeSource + */ + secretRef?: V1LocalObjectReference; + /** + * The rados user name. Default is admin. More info: https://releases.k8s.io/HEAD/examples/volumes/rbd/README.md#how-to-use-it + * @type {string} + * @memberof V1RBDVolumeSource + */ + user?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ReplicaSet.ts b/frontend/packages/kube-types/src/openshift/V1ReplicaSet.ts new file mode 100644 index 00000000000..17aa73b3f07 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ReplicaSet.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ReplicaSetSpec } from './V1ReplicaSetSpec'; +import { V1ReplicaSetStatus } from './V1ReplicaSetStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ReplicaSet ensures that a specified number of pod replicas are running at any given time. + * @export + * @interface V1ReplicaSet + */ +export interface V1ReplicaSet { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ReplicaSet + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ReplicaSet + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1ReplicaSet + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1ReplicaSetSpec} + * @memberof V1ReplicaSet + */ + spec?: V1ReplicaSetSpec; + /** + * + * @type {V1ReplicaSetStatus} + * @memberof V1ReplicaSet + */ + status?: V1ReplicaSetStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ReplicaSetCondition.ts b/frontend/packages/kube-types/src/openshift/V1ReplicaSetCondition.ts new file mode 100644 index 00000000000..ad7477a36ee --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ReplicaSetCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ReplicaSetCondition describes the state of a replica set at a certain point. + * @export + * @interface V1ReplicaSetCondition + */ +export interface V1ReplicaSetCondition { + /** + * + * @type {string} + * @memberof V1ReplicaSetCondition + */ + lastTransitionTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof V1ReplicaSetCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof V1ReplicaSetCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1ReplicaSetCondition + */ + status: string; + /** + * Type of replica set condition. + * @type {string} + * @memberof V1ReplicaSetCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ReplicaSetList.ts b/frontend/packages/kube-types/src/openshift/V1ReplicaSetList.ts new file mode 100644 index 00000000000..531ec8ecb34 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ReplicaSetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ReplicaSet } from './V1ReplicaSet'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ReplicaSetList is a collection of ReplicaSets. + * @export + * @interface V1ReplicaSetList + */ +export interface V1ReplicaSetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ReplicaSetList + */ + apiVersion?: string; + /** + * List of ReplicaSets. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller + * @type {Array} + * @memberof V1ReplicaSetList + */ + items: V1ReplicaSet[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ReplicaSetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1ReplicaSetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ReplicaSetSpec.ts b/frontend/packages/kube-types/src/openshift/V1ReplicaSetSpec.ts new file mode 100644 index 00000000000..dbcd1aeb335 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ReplicaSetSpec.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * ReplicaSetSpec is the specification of a ReplicaSet. + * @export + * @interface V1ReplicaSetSpec + */ +export interface V1ReplicaSetSpec { + /** + * Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) + * @type {number} + * @memberof V1ReplicaSetSpec + */ + minReadySeconds?: number; + /** + * Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller + * @type {number} + * @memberof V1ReplicaSetSpec + */ + replicas?: number; + /** + * + * @type {V1LabelSelector} + * @memberof V1ReplicaSetSpec + */ + selector: V1LabelSelector; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1ReplicaSetSpec + */ + template?: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ReplicaSetStatus.ts b/frontend/packages/kube-types/src/openshift/V1ReplicaSetStatus.ts new file mode 100644 index 00000000000..c210ce36210 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ReplicaSetStatus.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ReplicaSetCondition } from './V1ReplicaSetCondition'; + +/** + * ReplicaSetStatus represents the current status of a ReplicaSet. + * @export + * @interface V1ReplicaSetStatus + */ +export interface V1ReplicaSetStatus { + /** + * The number of available replicas (ready for at least minReadySeconds) for this replica set. + * @type {number} + * @memberof V1ReplicaSetStatus + */ + availableReplicas?: number; + /** + * Represents the latest available observations of a replica set\'s current state. + * @type {Array} + * @memberof V1ReplicaSetStatus + */ + conditions?: V1ReplicaSetCondition[]; + /** + * The number of pods that have labels matching the labels of the pod template of the replicaset. + * @type {number} + * @memberof V1ReplicaSetStatus + */ + fullyLabeledReplicas?: number; + /** + * ObservedGeneration reflects the generation of the most recently observed ReplicaSet. + * @type {number} + * @memberof V1ReplicaSetStatus + */ + observedGeneration?: number; + /** + * The number of ready replicas for this replica set. + * @type {number} + * @memberof V1ReplicaSetStatus + */ + readyReplicas?: number; + /** + * Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller + * @type {number} + * @memberof V1ReplicaSetStatus + */ + replicas: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ReplicationController.ts b/frontend/packages/kube-types/src/openshift/V1ReplicationController.ts new file mode 100644 index 00000000000..650fbd5085e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ReplicationController.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ReplicationControllerSpec } from './V1ReplicationControllerSpec'; +import { V1ReplicationControllerStatus } from './V1ReplicationControllerStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ReplicationController represents the configuration of a replication controller. + * @export + * @interface V1ReplicationController + */ +export interface V1ReplicationController { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ReplicationController + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ReplicationController + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1ReplicationController + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1ReplicationControllerSpec} + * @memberof V1ReplicationController + */ + spec?: V1ReplicationControllerSpec; + /** + * + * @type {V1ReplicationControllerStatus} + * @memberof V1ReplicationController + */ + status?: V1ReplicationControllerStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ReplicationControllerCondition.ts b/frontend/packages/kube-types/src/openshift/V1ReplicationControllerCondition.ts new file mode 100644 index 00000000000..a14047ae14f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ReplicationControllerCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ReplicationControllerCondition describes the state of a replication controller at a certain point. + * @export + * @interface V1ReplicationControllerCondition + */ +export interface V1ReplicationControllerCondition { + /** + * + * @type {string} + * @memberof V1ReplicationControllerCondition + */ + lastTransitionTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof V1ReplicationControllerCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof V1ReplicationControllerCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1ReplicationControllerCondition + */ + status: string; + /** + * Type of replication controller condition. + * @type {string} + * @memberof V1ReplicationControllerCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ReplicationControllerList.ts b/frontend/packages/kube-types/src/openshift/V1ReplicationControllerList.ts new file mode 100644 index 00000000000..67ed9c412be --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ReplicationControllerList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ReplicationController } from './V1ReplicationController'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ReplicationControllerList is a collection of replication controllers. + * @export + * @interface V1ReplicationControllerList + */ +export interface V1ReplicationControllerList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ReplicationControllerList + */ + apiVersion?: string; + /** + * List of replication controllers. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller + * @type {Array} + * @memberof V1ReplicationControllerList + */ + items: V1ReplicationController[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ReplicationControllerList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1ReplicationControllerList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ReplicationControllerSpec.ts b/frontend/packages/kube-types/src/openshift/V1ReplicationControllerSpec.ts new file mode 100644 index 00000000000..6c8df21240d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ReplicationControllerSpec.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; + +/** + * ReplicationControllerSpec is the specification of a replication controller. + * @export + * @interface V1ReplicationControllerSpec + */ +export interface V1ReplicationControllerSpec { + /** + * Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) + * @type {number} + * @memberof V1ReplicationControllerSpec + */ + minReadySeconds?: number; + /** + * Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller + * @type {number} + * @memberof V1ReplicationControllerSpec + */ + replicas?: number; + /** + * Selector is a label query over pods that should match the Replicas count. If Selector is empty, it is defaulted to the labels present on the Pod template. Label keys and values that must match in order to be controlled by this replication controller, if empty defaulted to labels on Pod template. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors + * @type {{ [key: string]: string; }} + * @memberof V1ReplicationControllerSpec + */ + selector?: { [key: string]: string }; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1ReplicationControllerSpec + */ + template?: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ReplicationControllerStatus.ts b/frontend/packages/kube-types/src/openshift/V1ReplicationControllerStatus.ts new file mode 100644 index 00000000000..10e5f9d79e4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ReplicationControllerStatus.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ReplicationControllerCondition } from './V1ReplicationControllerCondition'; + +/** + * ReplicationControllerStatus represents the current status of a replication controller. + * @export + * @interface V1ReplicationControllerStatus + */ +export interface V1ReplicationControllerStatus { + /** + * The number of available replicas (ready for at least minReadySeconds) for this replication controller. + * @type {number} + * @memberof V1ReplicationControllerStatus + */ + availableReplicas?: number; + /** + * Represents the latest available observations of a replication controller\'s current state. + * @type {Array} + * @memberof V1ReplicationControllerStatus + */ + conditions?: V1ReplicationControllerCondition[]; + /** + * The number of pods that have labels matching the labels of the pod template of the replication controller. + * @type {number} + * @memberof V1ReplicationControllerStatus + */ + fullyLabeledReplicas?: number; + /** + * ObservedGeneration reflects the generation of the most recently observed replication controller. + * @type {number} + * @memberof V1ReplicationControllerStatus + */ + observedGeneration?: number; + /** + * The number of ready replicas for this replication controller. + * @type {number} + * @memberof V1ReplicationControllerStatus + */ + readyReplicas?: number; + /** + * Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#what-is-a-replicationcontroller + * @type {number} + * @memberof V1ReplicationControllerStatus + */ + replicas: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ResourceAttributes.ts b/frontend/packages/kube-types/src/openshift/V1ResourceAttributes.ts new file mode 100644 index 00000000000..7763012e9d9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ResourceAttributes.ts @@ -0,0 +1,62 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ResourceAttributes includes the authorization attributes available for resource requests to the Authorizer interface + * @export + * @interface V1ResourceAttributes + */ +export interface V1ResourceAttributes { + /** + * Group is the API Group of the Resource. \"*\" means all. + * @type {string} + * @memberof V1ResourceAttributes + */ + group?: string; + /** + * Name is the name of the resource being requested for a \"get\" or deleted for a \"delete\". \"\" (empty) means all. + * @type {string} + * @memberof V1ResourceAttributes + */ + name?: string; + /** + * Namespace is the namespace of the action being requested. Currently, there is no distinction between no namespace and all namespaces \"\" (empty) is defaulted for LocalSubjectAccessReviews \"\" (empty) is empty for cluster-scoped resources \"\" (empty) means \"all\" for namespace scoped resources from a SubjectAccessReview or SelfSubjectAccessReview + * @type {string} + * @memberof V1ResourceAttributes + */ + namespace?: string; + /** + * Resource is one of the existing resource types. \"*\" means all. + * @type {string} + * @memberof V1ResourceAttributes + */ + resource?: string; + /** + * Subresource is one of the existing resource types. \"\" means none. + * @type {string} + * @memberof V1ResourceAttributes + */ + subresource?: string; + /** + * Verb is a kubernetes resource API verb, like: get, list, watch, create, update, delete, proxy. \"*\" means all. + * @type {string} + * @memberof V1ResourceAttributes + */ + verb?: string; + /** + * Version is the API Version of the Resource. \"*\" means all. + * @type {string} + * @memberof V1ResourceAttributes + */ + version?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ResourceFieldSelector.ts b/frontend/packages/kube-types/src/openshift/V1ResourceFieldSelector.ts new file mode 100644 index 00000000000..d9d301071f4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ResourceFieldSelector.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ResourceFieldSelector represents container resources (cpu, memory) and their output format + * @export + * @interface V1ResourceFieldSelector + */ +export interface V1ResourceFieldSelector { + /** + * Container name: required for volumes, optional for env vars + * @type {string} + * @memberof V1ResourceFieldSelector + */ + containerName?: string; + /** + * + * @type {string} + * @memberof V1ResourceFieldSelector + */ + divisor?: string; + /** + * Required: resource to select + * @type {string} + * @memberof V1ResourceFieldSelector + */ + resource: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ResourceQuota.ts b/frontend/packages/kube-types/src/openshift/V1ResourceQuota.ts new file mode 100644 index 00000000000..2d2c88e5c52 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ResourceQuota.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ResourceQuotaSpec } from './V1ResourceQuotaSpec'; +import { V1ResourceQuotaStatus } from './V1ResourceQuotaStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ResourceQuota sets aggregate quota restrictions enforced per namespace + * @export + * @interface V1ResourceQuota + */ +export interface V1ResourceQuota { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ResourceQuota + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ResourceQuota + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1ResourceQuota + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1ResourceQuotaSpec} + * @memberof V1ResourceQuota + */ + spec?: V1ResourceQuotaSpec; + /** + * + * @type {V1ResourceQuotaStatus} + * @memberof V1ResourceQuota + */ + status?: V1ResourceQuotaStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ResourceQuotaList.ts b/frontend/packages/kube-types/src/openshift/V1ResourceQuotaList.ts new file mode 100644 index 00000000000..0a92d27712d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ResourceQuotaList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ResourceQuota } from './V1ResourceQuota'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ResourceQuotaList is a list of ResourceQuota items. + * @export + * @interface V1ResourceQuotaList + */ +export interface V1ResourceQuotaList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ResourceQuotaList + */ + apiVersion?: string; + /** + * Items is a list of ResourceQuota objects. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/ + * @type {Array} + * @memberof V1ResourceQuotaList + */ + items: V1ResourceQuota[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ResourceQuotaList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1ResourceQuotaList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ResourceQuotaSpec.ts b/frontend/packages/kube-types/src/openshift/V1ResourceQuotaSpec.ts new file mode 100644 index 00000000000..b682dcc3fcd --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ResourceQuotaSpec.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ScopeSelector } from './V1ScopeSelector'; + +/** + * ResourceQuotaSpec defines the desired hard limits to enforce for Quota. + * @export + * @interface V1ResourceQuotaSpec + */ +export interface V1ResourceQuotaSpec { + /** + * hard is the set of desired hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/ + * @type {{ [key: string]: string; }} + * @memberof V1ResourceQuotaSpec + */ + hard?: { [key: string]: string }; + /** + * + * @type {V1ScopeSelector} + * @memberof V1ResourceQuotaSpec + */ + scopeSelector?: V1ScopeSelector; + /** + * A collection of filters that must match each object tracked by a quota. If not specified, the quota matches all objects. + * @type {Array} + * @memberof V1ResourceQuotaSpec + */ + scopes?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ResourceQuotaStatus.ts b/frontend/packages/kube-types/src/openshift/V1ResourceQuotaStatus.ts new file mode 100644 index 00000000000..683c7339d80 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ResourceQuotaStatus.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ResourceQuotaStatus defines the enforced hard limits and observed use. + * @export + * @interface V1ResourceQuotaStatus + */ +export interface V1ResourceQuotaStatus { + /** + * Hard is the set of enforced hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/ + * @type {{ [key: string]: string; }} + * @memberof V1ResourceQuotaStatus + */ + hard?: { [key: string]: string }; + /** + * Used is the current observed total usage of the resource in the namespace. + * @type {{ [key: string]: string; }} + * @memberof V1ResourceQuotaStatus + */ + used?: { [key: string]: string }; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ResourceRequirements.ts b/frontend/packages/kube-types/src/openshift/V1ResourceRequirements.ts new file mode 100644 index 00000000000..930756a6ee1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ResourceRequirements.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ResourceRequirements describes the compute resource requirements. + * @export + * @interface V1ResourceRequirements + */ +export interface V1ResourceRequirements { + /** + * Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/ + * @type {{ [key: string]: string; }} + * @memberof V1ResourceRequirements + */ + limits?: { [key: string]: string }; + /** + * Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/ + * @type {{ [key: string]: string; }} + * @memberof V1ResourceRequirements + */ + requests?: { [key: string]: string }; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ResourceRule.ts b/frontend/packages/kube-types/src/openshift/V1ResourceRule.ts new file mode 100644 index 00000000000..27b2623fd18 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ResourceRule.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ResourceRule is the list of actions the subject is allowed to perform on resources. The list ordering isn\'t significant, may contain duplicates, and possibly be incomplete. + * @export + * @interface V1ResourceRule + */ +export interface V1ResourceRule { + /** + * APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. \"*\" means all. + * @type {Array} + * @memberof V1ResourceRule + */ + apiGroups?: string[]; + /** + * ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. \"*\" means all. + * @type {Array} + * @memberof V1ResourceRule + */ + resourceNames?: string[]; + /** + * Resources is a list of resources this rule applies to. \"*\" means all in the specified apiGroups. \"*_/foo\" represents the subresource \'foo\' for all resources in the specified apiGroups. + * @type {Array} + * @memberof V1ResourceRule + */ + resources?: string[]; + /** + * Verb is a list of kubernetes resource API verbs, like: get, list, watch, create, update, delete, proxy. \"*\" means all. + * @type {Array} + * @memberof V1ResourceRule + */ + verbs: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Role.ts b/frontend/packages/kube-types/src/openshift/V1Role.ts new file mode 100644 index 00000000000..bf836c8abf5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Role.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PolicyRule } from './V1PolicyRule'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. + * @export + * @interface V1Role + */ +export interface V1Role { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Role + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Role + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Role + */ + metadata?: V1ObjectMeta; + /** + * Rules holds all the PolicyRules for this Role + * @type {Array} + * @memberof V1Role + */ + rules: V1PolicyRule[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RoleBinding.ts b/frontend/packages/kube-types/src/openshift/V1RoleBinding.ts new file mode 100644 index 00000000000..b2a376a125e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RoleBinding.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1RoleRef } from './V1RoleRef'; +import { V1Subject } from './V1Subject'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. + * @export + * @interface V1RoleBinding + */ +export interface V1RoleBinding { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1RoleBinding + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1RoleBinding + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1RoleBinding + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1RoleRef} + * @memberof V1RoleBinding + */ + roleRef: V1RoleRef; + /** + * Subjects holds references to the objects the role applies to. + * @type {Array} + * @memberof V1RoleBinding + */ + subjects?: V1Subject[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RoleBindingList.ts b/frontend/packages/kube-types/src/openshift/V1RoleBindingList.ts new file mode 100644 index 00000000000..66ec2892d11 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RoleBindingList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1RoleBinding } from './V1RoleBinding'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * RoleBindingList is a collection of RoleBindings + * @export + * @interface V1RoleBindingList + */ +export interface V1RoleBindingList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1RoleBindingList + */ + apiVersion?: string; + /** + * Items is a list of RoleBindings + * @type {Array} + * @memberof V1RoleBindingList + */ + items: V1RoleBinding[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1RoleBindingList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1RoleBindingList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RoleList.ts b/frontend/packages/kube-types/src/openshift/V1RoleList.ts new file mode 100644 index 00000000000..8d16c76dcc9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RoleList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Role } from './V1Role'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * RoleList is a collection of Roles + * @export + * @interface V1RoleList + */ +export interface V1RoleList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1RoleList + */ + apiVersion?: string; + /** + * Items is a list of Roles + * @type {Array} + * @memberof V1RoleList + */ + items: V1Role[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1RoleList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1RoleList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RoleRef.ts b/frontend/packages/kube-types/src/openshift/V1RoleRef.ts new file mode 100644 index 00000000000..462d6ab08d9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RoleRef.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RoleRef contains information that points to the role being used + * @export + * @interface V1RoleRef + */ +export interface V1RoleRef { + /** + * APIGroup is the group for the resource being referenced + * @type {string} + * @memberof V1RoleRef + */ + apiGroup: string; + /** + * Kind is the type of resource being referenced + * @type {string} + * @memberof V1RoleRef + */ + kind: string; + /** + * Name is the name of resource being referenced + * @type {string} + * @memberof V1RoleRef + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RollingUpdateDaemonSet.ts b/frontend/packages/kube-types/src/openshift/V1RollingUpdateDaemonSet.ts new file mode 100644 index 00000000000..bf4af40e612 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RollingUpdateDaemonSet.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Spec to control the desired behavior of daemon set rolling update. + * @export + * @interface V1RollingUpdateDaemonSet + */ +export interface V1RollingUpdateDaemonSet { + /** + * + * @type {string} + * @memberof V1RollingUpdateDaemonSet + */ + maxUnavailable?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RollingUpdateDeployment.ts b/frontend/packages/kube-types/src/openshift/V1RollingUpdateDeployment.ts new file mode 100644 index 00000000000..8deffe4d0d5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RollingUpdateDeployment.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Spec to control the desired behavior of rolling update. + * @export + * @interface V1RollingUpdateDeployment + */ +export interface V1RollingUpdateDeployment { + /** + * + * @type {string} + * @memberof V1RollingUpdateDeployment + */ + maxSurge?: string; + /** + * + * @type {string} + * @memberof V1RollingUpdateDeployment + */ + maxUnavailable?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RollingUpdateStatefulSetStrategy.ts b/frontend/packages/kube-types/src/openshift/V1RollingUpdateStatefulSetStrategy.ts new file mode 100644 index 00000000000..dd969f8a8a7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RollingUpdateStatefulSetStrategy.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. + * @export + * @interface V1RollingUpdateStatefulSetStrategy + */ +export interface V1RollingUpdateStatefulSetStrategy { + /** + * Partition indicates the ordinal at which the StatefulSet should be partitioned. Default value is 0. + * @type {number} + * @memberof V1RollingUpdateStatefulSetStrategy + */ + partition?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Route.ts b/frontend/packages/kube-types/src/openshift/V1Route.ts new file mode 100644 index 00000000000..ec398bcf9a3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Route.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1RouteSpec } from './V1RouteSpec'; +import { V1RouteStatus } from './V1RouteStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * A route allows developers to expose services through an HTTP(S) aware load balancing and proxy layer via a public DNS entry. The route may further specify TLS options and a certificate, or specify a public CNAME that the router should also accept for HTTP and HTTPS traffic. An administrator typically configures their router to be visible outside the cluster firewall, and may also add additional security, caching, or traffic controls on the service content. Routers usually talk directly to the service endpoints. Once a route is created, the `host` field may not be changed. Generally, routers use the oldest route with a given host when resolving conflicts. Routers are subject to additional customization and may support additional controls via the annotations field. Because administrators may configure multiple routers, the route status field is used to return information to clients about the names and states of the route under each router. If a client chooses a duplicate name, for instance, the route status conditions are used to indicate the route cannot be chosen. + * @export + * @interface V1Route + */ +export interface V1Route { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Route + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Route + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Route + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1RouteSpec} + * @memberof V1Route + */ + spec: V1RouteSpec; + /** + * + * @type {V1RouteStatus} + * @memberof V1Route + */ + status: V1RouteStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RouteIngress.ts b/frontend/packages/kube-types/src/openshift/V1RouteIngress.ts new file mode 100644 index 00000000000..355af0c0317 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RouteIngress.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1RouteIngressCondition } from './V1RouteIngressCondition'; + +/** + * RouteIngress holds information about the places where a route is exposed. + * @export + * @interface V1RouteIngress + */ +export interface V1RouteIngress { + /** + * Conditions is the state of the route, may be empty. + * @type {Array} + * @memberof V1RouteIngress + */ + conditions?: V1RouteIngressCondition[]; + /** + * Host is the host string under which the route is exposed; this value is required + * @type {string} + * @memberof V1RouteIngress + */ + host?: string; + /** + * CanonicalHostname is the external host name for the router that can be used as a CNAME for the host requested for this route. This value is optional and may not be set in all cases. + * @type {string} + * @memberof V1RouteIngress + */ + routerCanonicalHostname?: string; + /** + * Name is a name chosen by the router to identify itself; this value is required + * @type {string} + * @memberof V1RouteIngress + */ + routerName?: string; + /** + * Wildcard policy is the wildcard policy that was allowed where this route is exposed. + * @type {string} + * @memberof V1RouteIngress + */ + wildcardPolicy?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RouteIngressCondition.ts b/frontend/packages/kube-types/src/openshift/V1RouteIngressCondition.ts new file mode 100644 index 00000000000..34978526ddb --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RouteIngressCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RouteIngressCondition contains details for the current condition of this route on a particular router. + * @export + * @interface V1RouteIngressCondition + */ +export interface V1RouteIngressCondition { + /** + * + * @type {string} + * @memberof V1RouteIngressCondition + */ + lastTransitionTime?: string; + /** + * Human readable message indicating details about last transition. + * @type {string} + * @memberof V1RouteIngressCondition + */ + message?: string; + /** + * (brief) reason for the condition\'s last transition, and is usually a machine and human readable constant + * @type {string} + * @memberof V1RouteIngressCondition + */ + reason?: string; + /** + * Status is the status of the condition. Can be True, False, Unknown. + * @type {string} + * @memberof V1RouteIngressCondition + */ + status: string; + /** + * Type is the type of the condition. Currently only Ready. + * @type {string} + * @memberof V1RouteIngressCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RouteList.ts b/frontend/packages/kube-types/src/openshift/V1RouteList.ts new file mode 100644 index 00000000000..99b2f59fcbf --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RouteList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Route } from './V1Route'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * RouteList is a collection of Routes. + * @export + * @interface V1RouteList + */ +export interface V1RouteList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1RouteList + */ + apiVersion?: string; + /** + * items is a list of routes + * @type {Array} + * @memberof V1RouteList + */ + items: V1Route[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1RouteList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1RouteList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RoutePort.ts b/frontend/packages/kube-types/src/openshift/V1RoutePort.ts new file mode 100644 index 00000000000..8e37c35d7bd --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RoutePort.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RoutePort defines a port mapping from a router to an endpoint in the service endpoints. + * @export + * @interface V1RoutePort + */ +export interface V1RoutePort { + /** + * + * @type {string} + * @memberof V1RoutePort + */ + targetPort: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RouteSpec.ts b/frontend/packages/kube-types/src/openshift/V1RouteSpec.ts new file mode 100644 index 00000000000..05ef42c9784 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RouteSpec.ts @@ -0,0 +1,66 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1RoutePort } from './V1RoutePort'; +import { V1RouteTargetReference } from './V1RouteTargetReference'; +import { V1TLSConfig } from './V1TLSConfig'; + +/** + * RouteSpec describes the hostname or path the route exposes, any security information, and one to four backends (services) the route points to. Requests are distributed among the backends depending on the weights assigned to each backend. When using roundrobin scheduling the portion of requests that go to each backend is the backend weight divided by the sum of all of the backend weights. When the backend has more than one endpoint the requests that end up on the backend are roundrobin distributed among the endpoints. Weights are between 0 and 256 with default 1. Weight 0 causes no requests to the backend. If all weights are zero the route will be considered to have no backends and return a standard 503 response. The `tls` field is optional and allows specific certificates or behavior for the route. Routers typically configure a default certificate on a wildcard domain to terminate routes without explicit certificates, but custom hostnames usually must choose passthrough (send traffic directly to the backend via the TLS Server-Name- Indication field) or provide a certificate. + * @export + * @interface V1RouteSpec + */ +export interface V1RouteSpec { + /** + * alternateBackends allows up to 3 additional backends to be assigned to the route. Only the Service kind is allowed, and it will be defaulted to Service. Use the weight field in RouteTargetReference object to specify relative preference. + * @type {Array} + * @memberof V1RouteSpec + */ + alternateBackends?: V1RouteTargetReference[]; + /** + * host is an alias/DNS that points to the service. Optional. If not specified a route name will typically be automatically chosen. Must follow DNS952 subdomain conventions. + * @type {string} + * @memberof V1RouteSpec + */ + host: string; + /** + * Path that the router watches for, to route traffic for to the service. Optional + * @type {string} + * @memberof V1RouteSpec + */ + path?: string; + /** + * + * @type {V1RoutePort} + * @memberof V1RouteSpec + */ + port?: V1RoutePort; + /** + * + * @type {V1TLSConfig} + * @memberof V1RouteSpec + */ + tls?: V1TLSConfig; + /** + * + * @type {V1RouteTargetReference} + * @memberof V1RouteSpec + */ + to: V1RouteTargetReference; + /** + * Wildcard policy if any for the route. Currently only \'Subdomain\' or \'None\' is allowed. + * @type {string} + * @memberof V1RouteSpec + */ + wildcardPolicy?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RouteStatus.ts b/frontend/packages/kube-types/src/openshift/V1RouteStatus.ts new file mode 100644 index 00000000000..707e61670ca --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RouteStatus.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1RouteIngress } from './V1RouteIngress'; + +/** + * RouteStatus provides relevant info about the status of a route, including which routers acknowledge it. + * @export + * @interface V1RouteStatus + */ +export interface V1RouteStatus { + /** + * ingress describes the places where the route may be exposed. The list of ingress points may contain duplicate Host or RouterName values. Routes are considered live once they are `Ready` + * @type {Array} + * @memberof V1RouteStatus + */ + ingress: V1RouteIngress[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1RouteTargetReference.ts b/frontend/packages/kube-types/src/openshift/V1RouteTargetReference.ts new file mode 100644 index 00000000000..9b71a157ba8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1RouteTargetReference.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RouteTargetReference specifies the target that resolve into endpoints. Only the \'Service\' kind is allowed. Use \'weight\' field to emphasize one over others. + * @export + * @interface V1RouteTargetReference + */ +export interface V1RouteTargetReference { + /** + * The kind of target that the route is referring to. Currently, only \'Service\' is allowed + * @type {string} + * @memberof V1RouteTargetReference + */ + kind: string; + /** + * name of the service/target that is being referred to. e.g. name of the service + * @type {string} + * @memberof V1RouteTargetReference + */ + name: string; + /** + * weight as an integer between 0 and 256, default 1, that specifies the target\'s relative weight against other target reference objects. 0 suppresses requests to this backend. + * @type {number} + * @memberof V1RouteTargetReference + */ + weight: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SELinuxOptions.ts b/frontend/packages/kube-types/src/openshift/V1SELinuxOptions.ts new file mode 100644 index 00000000000..167b0ca69c9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SELinuxOptions.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SELinuxOptions are the labels to be applied to the container + * @export + * @interface V1SELinuxOptions + */ +export interface V1SELinuxOptions { + /** + * Level is SELinux level label that applies to the container. + * @type {string} + * @memberof V1SELinuxOptions + */ + level?: string; + /** + * Role is a SELinux role label that applies to the container. + * @type {string} + * @memberof V1SELinuxOptions + */ + role?: string; + /** + * Type is a SELinux type label that applies to the container. + * @type {string} + * @memberof V1SELinuxOptions + */ + type?: string; + /** + * User is a SELinux user label that applies to the container. + * @type {string} + * @memberof V1SELinuxOptions + */ + user?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Scale.ts b/frontend/packages/kube-types/src/openshift/V1Scale.ts new file mode 100644 index 00000000000..7936cd14722 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Scale.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ScaleSpec } from './V1ScaleSpec'; +import { V1ScaleStatus } from './V1ScaleStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Scale represents a scaling request for a resource. + * @export + * @interface V1Scale + */ +export interface V1Scale { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Scale + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Scale + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Scale + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1ScaleSpec} + * @memberof V1Scale + */ + spec?: V1ScaleSpec; + /** + * + * @type {V1ScaleStatus} + * @memberof V1Scale + */ + status?: V1ScaleStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ScaleIOPersistentVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1ScaleIOPersistentVolumeSource.ts new file mode 100644 index 00000000000..0b460e7e72e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ScaleIOPersistentVolumeSource.ts @@ -0,0 +1,82 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SecretReference } from './V1SecretReference'; + +/** + * ScaleIOPersistentVolumeSource represents a persistent ScaleIO volume + * @export + * @interface V1ScaleIOPersistentVolumeSource + */ +export interface V1ScaleIOPersistentVolumeSource { + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. + * @type {string} + * @memberof V1ScaleIOPersistentVolumeSource + */ + fsType?: string; + /** + * The host address of the ScaleIO API Gateway. + * @type {string} + * @memberof V1ScaleIOPersistentVolumeSource + */ + gateway: string; + /** + * The name of the ScaleIO Protection Domain for the configured storage. + * @type {string} + * @memberof V1ScaleIOPersistentVolumeSource + */ + protectionDomain?: string; + /** + * Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. + * @type {boolean} + * @memberof V1ScaleIOPersistentVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1SecretReference} + * @memberof V1ScaleIOPersistentVolumeSource + */ + secretRef: V1SecretReference; + /** + * Flag to enable/disable SSL communication with Gateway, default false + * @type {boolean} + * @memberof V1ScaleIOPersistentVolumeSource + */ + sslEnabled?: boolean; + /** + * Indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. + * @type {string} + * @memberof V1ScaleIOPersistentVolumeSource + */ + storageMode?: string; + /** + * The ScaleIO Storage Pool associated with the protection domain. + * @type {string} + * @memberof V1ScaleIOPersistentVolumeSource + */ + storagePool?: string; + /** + * The name of the storage system as configured in ScaleIO. + * @type {string} + * @memberof V1ScaleIOPersistentVolumeSource + */ + system: string; + /** + * The name of a volume already created in the ScaleIO system that is associated with this volume source. + * @type {string} + * @memberof V1ScaleIOPersistentVolumeSource + */ + volumeName?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ScaleIOVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1ScaleIOVolumeSource.ts new file mode 100644 index 00000000000..624945530f6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ScaleIOVolumeSource.ts @@ -0,0 +1,82 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * ScaleIOVolumeSource represents a persistent ScaleIO volume + * @export + * @interface V1ScaleIOVolumeSource + */ +export interface V1ScaleIOVolumeSource { + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. + * @type {string} + * @memberof V1ScaleIOVolumeSource + */ + fsType?: string; + /** + * The host address of the ScaleIO API Gateway. + * @type {string} + * @memberof V1ScaleIOVolumeSource + */ + gateway: string; + /** + * The name of the ScaleIO Protection Domain for the configured storage. + * @type {string} + * @memberof V1ScaleIOVolumeSource + */ + protectionDomain?: string; + /** + * Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. + * @type {boolean} + * @memberof V1ScaleIOVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1ScaleIOVolumeSource + */ + secretRef: V1LocalObjectReference; + /** + * Flag to enable/disable SSL communication with Gateway, default false + * @type {boolean} + * @memberof V1ScaleIOVolumeSource + */ + sslEnabled?: boolean; + /** + * Indicates whether the storage for a volume should be ThickProvisioned or ThinProvisioned. + * @type {string} + * @memberof V1ScaleIOVolumeSource + */ + storageMode?: string; + /** + * The ScaleIO Storage Pool associated with the protection domain. + * @type {string} + * @memberof V1ScaleIOVolumeSource + */ + storagePool?: string; + /** + * The name of the storage system as configured in ScaleIO. + * @type {string} + * @memberof V1ScaleIOVolumeSource + */ + system: string; + /** + * The name of a volume already created in the ScaleIO system that is associated with this volume source. + * @type {string} + * @memberof V1ScaleIOVolumeSource + */ + volumeName?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ScaleSpec.ts b/frontend/packages/kube-types/src/openshift/V1ScaleSpec.ts new file mode 100644 index 00000000000..65d1b24a25a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ScaleSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ScaleSpec describes the attributes of a scale subresource. + * @export + * @interface V1ScaleSpec + */ +export interface V1ScaleSpec { + /** + * desired number of instances for the scaled object. + * @type {number} + * @memberof V1ScaleSpec + */ + replicas?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ScaleStatus.ts b/frontend/packages/kube-types/src/openshift/V1ScaleStatus.ts new file mode 100644 index 00000000000..8237a48d629 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ScaleStatus.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ScaleStatus represents the current status of a scale subresource. + * @export + * @interface V1ScaleStatus + */ +export interface V1ScaleStatus { + /** + * actual number of observed instances of the scaled object. + * @type {number} + * @memberof V1ScaleStatus + */ + replicas: number; + /** + * label query over pods that should match the replicas count. This is same as the label selector but in the string format to avoid introspection by clients. The string will be in the same format as the query-param syntax. More info about label selectors: http://kubernetes.io/docs/user-guide/labels#label-selectors + * @type {string} + * @memberof V1ScaleStatus + */ + selector?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ScopeSelector.ts b/frontend/packages/kube-types/src/openshift/V1ScopeSelector.ts new file mode 100644 index 00000000000..35e9fa8ef8b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ScopeSelector.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ScopedResourceSelectorRequirement } from './V1ScopedResourceSelectorRequirement'; + +/** + * A scope selector represents the AND of the selectors represented by the scoped-resource selector requirements. + * @export + * @interface V1ScopeSelector + */ +export interface V1ScopeSelector { + /** + * A list of scope selector requirements by scope of the resources. + * @type {Array} + * @memberof V1ScopeSelector + */ + matchExpressions?: V1ScopedResourceSelectorRequirement[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ScopedResourceSelectorRequirement.ts b/frontend/packages/kube-types/src/openshift/V1ScopedResourceSelectorRequirement.ts new file mode 100644 index 00000000000..6a2a5a3828b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ScopedResourceSelectorRequirement.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * A scoped-resource selector requirement is a selector that contains values, a scope name, and an operator that relates the scope name and values. + * @export + * @interface V1ScopedResourceSelectorRequirement + */ +export interface V1ScopedResourceSelectorRequirement { + /** + * Represents a scope\'s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. + * @type {string} + * @memberof V1ScopedResourceSelectorRequirement + */ + operator: string; + /** + * The name of the scope that the selector applies to. + * @type {string} + * @memberof V1ScopedResourceSelectorRequirement + */ + scopeName: string; + /** + * An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + * @type {Array} + * @memberof V1ScopedResourceSelectorRequirement + */ + values?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Secret.ts b/frontend/packages/kube-types/src/openshift/V1Secret.ts new file mode 100644 index 00000000000..34498a9f59c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Secret.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes. + * @export + * @interface V1Secret + */ +export interface V1Secret { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Secret + */ + apiVersion?: string; + /** + * Data contains the secret data. Each key must consist of alphanumeric characters, \'-\', \'_\' or \'.\'. The serialized form of the secret data is a base64 encoded string, representing the arbitrary (possibly non-string) data value here. Described in https://tools.ietf.org/html/rfc4648#section-4 + * @type {{ [key: string]: string; }} + * @memberof V1Secret + */ + data?: { [key: string]: string }; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Secret + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Secret + */ + metadata?: V1ObjectMeta; + /** + * stringData allows specifying non-binary secret data in string form. It is provided as a write-only convenience method. All keys and values are merged into the data field on write, overwriting any existing values. It is never output when reading from the API. + * @type {{ [key: string]: string; }} + * @memberof V1Secret + */ + stringData?: { [key: string]: string }; + /** + * Used to facilitate programmatic handling of secret data. + * @type {string} + * @memberof V1Secret + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SecretEnvSource.ts b/frontend/packages/kube-types/src/openshift/V1SecretEnvSource.ts new file mode 100644 index 00000000000..9653f0e60bc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SecretEnvSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SecretEnvSource selects a Secret to populate the environment variables with. The contents of the target Secret\'s Data field will represent the key-value pairs as environment variables. + * @export + * @interface V1SecretEnvSource + */ +export interface V1SecretEnvSource { + /** + * Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1SecretEnvSource + */ + name?: string; + /** + * Specify whether the Secret must be defined + * @type {boolean} + * @memberof V1SecretEnvSource + */ + optional?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SecretKeySelector.ts b/frontend/packages/kube-types/src/openshift/V1SecretKeySelector.ts new file mode 100644 index 00000000000..77843a96759 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SecretKeySelector.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SecretKeySelector selects a key of a Secret. + * @export + * @interface V1SecretKeySelector + */ +export interface V1SecretKeySelector { + /** + * The key of the secret to select from. Must be a valid secret key. + * @type {string} + * @memberof V1SecretKeySelector + */ + key: string; + /** + * Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1SecretKeySelector + */ + name?: string; + /** + * Specify whether the Secret or it\'s key must be defined + * @type {boolean} + * @memberof V1SecretKeySelector + */ + optional?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SecretList.ts b/frontend/packages/kube-types/src/openshift/V1SecretList.ts new file mode 100644 index 00000000000..077e7ebb02c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SecretList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Secret } from './V1Secret'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * SecretList is a list of Secret. + * @export + * @interface V1SecretList + */ +export interface V1SecretList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1SecretList + */ + apiVersion?: string; + /** + * Items is a list of secret objects. More info: https://kubernetes.io/docs/concepts/configuration/secret + * @type {Array} + * @memberof V1SecretList + */ + items: V1Secret[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1SecretList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1SecretList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SecretProjection.ts b/frontend/packages/kube-types/src/openshift/V1SecretProjection.ts new file mode 100644 index 00000000000..ae526ee939a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SecretProjection.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1KeyToPath } from './V1KeyToPath'; + +/** + * Adapts a secret into a projected volume. The contents of the target Secret\'s Data field will be presented in a projected volume as files using the keys in the Data field as the file names. Note that this is identical to a secret volume source without the default mode. + * @export + * @interface V1SecretProjection + */ +export interface V1SecretProjection { + /** + * If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the \'..\' path or start with \'..\'. + * @type {Array} + * @memberof V1SecretProjection + */ + items?: V1KeyToPath[]; + /** + * Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1SecretProjection + */ + name?: string; + /** + * Specify whether the Secret or its key must be defined + * @type {boolean} + * @memberof V1SecretProjection + */ + optional?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SecretReference.ts b/frontend/packages/kube-types/src/openshift/V1SecretReference.ts new file mode 100644 index 00000000000..2b33235da8c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SecretReference.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace + * @export + * @interface V1SecretReference + */ +export interface V1SecretReference { + /** + * Name is unique within a namespace to reference a secret resource. + * @type {string} + * @memberof V1SecretReference + */ + name?: string; + /** + * Namespace defines the space within which the secret name must be unique. + * @type {string} + * @memberof V1SecretReference + */ + namespace?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SecretVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1SecretVolumeSource.ts new file mode 100644 index 00000000000..d40240255a9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SecretVolumeSource.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1KeyToPath } from './V1KeyToPath'; + +/** + * Adapts a Secret into a volume. The contents of the target Secret\'s Data field will be presented in a volume as files using the keys in the Data field as the file names. Secret volumes support ownership management and SELinux relabeling. + * @export + * @interface V1SecretVolumeSource + */ +export interface V1SecretVolumeSource { + /** + * Optional: mode bits to use on created files by default. Must be a value between 0 and 0777. Defaults to 0644. Directories within the path are not affected by this setting. This might be in conflict with other options that affect the file mode, like fsGroup, and the result can be other mode bits set. + * @type {number} + * @memberof V1SecretVolumeSource + */ + defaultMode?: number; + /** + * If unspecified, each key-value pair in the Data field of the referenced Secret will be projected into the volume as a file whose name is the key and content is the value. If specified, the listed keys will be projected into the specified paths, and unlisted keys will not be present. If a key is specified which is not present in the Secret, the volume setup will error unless it is marked optional. Paths must be relative and may not contain the \'..\' path or start with \'..\'. + * @type {Array} + * @memberof V1SecretVolumeSource + */ + items?: V1KeyToPath[]; + /** + * Specify whether the Secret or it\'s keys must be defined + * @type {boolean} + * @memberof V1SecretVolumeSource + */ + optional?: boolean; + /** + * Name of the secret in the pod\'s namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret + * @type {string} + * @memberof V1SecretVolumeSource + */ + secretName?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SecurityContext.ts b/frontend/packages/kube-types/src/openshift/V1SecurityContext.ts new file mode 100644 index 00000000000..c55c1416bfe --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SecurityContext.ts @@ -0,0 +1,71 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Capabilities } from './V1Capabilities'; +import { V1SELinuxOptions } from './V1SELinuxOptions'; + +/** + * SecurityContext holds security configuration that will be applied to a container. Some fields are present in both SecurityContext and PodSecurityContext. When both are set, the values in SecurityContext take precedence. + * @export + * @interface V1SecurityContext + */ +export interface V1SecurityContext { + /** + * AllowPrivilegeEscalation controls whether a process can gain more privileges than its parent process. This bool directly controls if the no_new_privs flag will be set on the container process. AllowPrivilegeEscalation is true always when the container is: 1) run as Privileged 2) has CAP_SYS_ADMIN + * @type {boolean} + * @memberof V1SecurityContext + */ + allowPrivilegeEscalation?: boolean; + /** + * + * @type {V1Capabilities} + * @memberof V1SecurityContext + */ + capabilities?: V1Capabilities; + /** + * Run container in privileged mode. Processes in privileged containers are essentially equivalent to root on the host. Defaults to false. + * @type {boolean} + * @memberof V1SecurityContext + */ + privileged?: boolean; + /** + * Whether this container has a read-only root filesystem. Default is false. + * @type {boolean} + * @memberof V1SecurityContext + */ + readOnlyRootFilesystem?: boolean; + /** + * The GID to run the entrypoint of the container process. Uses runtime default if unset. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + * @type {number} + * @memberof V1SecurityContext + */ + runAsGroup?: number; + /** + * Indicates that the container must run as a non-root user. If true, the Kubelet will validate the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the container if it does. If unset or false, no such validation will be performed. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + * @type {boolean} + * @memberof V1SecurityContext + */ + runAsNonRoot?: boolean; + /** + * The UID to run the entrypoint of the container process. Defaults to user specified in image metadata if unspecified. May also be set in PodSecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence. + * @type {number} + * @memberof V1SecurityContext + */ + runAsUser?: number; + /** + * + * @type {V1SELinuxOptions} + * @memberof V1SecurityContext + */ + seLinuxOptions?: V1SELinuxOptions; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SelfSubjectAccessReview.ts b/frontend/packages/kube-types/src/openshift/V1SelfSubjectAccessReview.ts new file mode 100644 index 00000000000..473e4d48d97 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SelfSubjectAccessReview.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SelfSubjectAccessReviewSpec } from './V1SelfSubjectAccessReviewSpec'; +import { V1SubjectAccessReviewStatus } from './V1SubjectAccessReviewStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * SelfSubjectAccessReview checks whether or the current user can perform an action. Not filling in a spec.namespace means \"in all namespaces\". Self is a special case, because users should always be able to check whether they can perform an action + * @export + * @interface V1SelfSubjectAccessReview + */ +export interface V1SelfSubjectAccessReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1SelfSubjectAccessReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1SelfSubjectAccessReview + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1SelfSubjectAccessReview + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1SelfSubjectAccessReviewSpec} + * @memberof V1SelfSubjectAccessReview + */ + spec: V1SelfSubjectAccessReviewSpec; + /** + * + * @type {V1SubjectAccessReviewStatus} + * @memberof V1SelfSubjectAccessReview + */ + status?: V1SubjectAccessReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SelfSubjectAccessReviewSpec.ts b/frontend/packages/kube-types/src/openshift/V1SelfSubjectAccessReviewSpec.ts new file mode 100644 index 00000000000..445231ee4d2 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SelfSubjectAccessReviewSpec.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NonResourceAttributes } from './V1NonResourceAttributes'; +import { V1ResourceAttributes } from './V1ResourceAttributes'; + +/** + * SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set + * @export + * @interface V1SelfSubjectAccessReviewSpec + */ +export interface V1SelfSubjectAccessReviewSpec { + /** + * + * @type {V1NonResourceAttributes} + * @memberof V1SelfSubjectAccessReviewSpec + */ + nonResourceAttributes?: V1NonResourceAttributes; + /** + * + * @type {V1ResourceAttributes} + * @memberof V1SelfSubjectAccessReviewSpec + */ + resourceAttributes?: V1ResourceAttributes; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SelfSubjectRulesReview.ts b/frontend/packages/kube-types/src/openshift/V1SelfSubjectRulesReview.ts new file mode 100644 index 00000000000..8c8d03264c9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SelfSubjectRulesReview.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SelfSubjectRulesReviewSpec } from './V1SelfSubjectRulesReviewSpec'; +import { V1SubjectRulesReviewStatus } from './V1SubjectRulesReviewStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * SelfSubjectRulesReview enumerates the set of actions the current user can perform within a namespace. The returned list of actions may be incomplete depending on the server\'s authorization mode, and any errors experienced during the evaluation. SelfSubjectRulesReview should be used by UIs to show/hide actions, or to quickly let an end user reason about their permissions. It should NOT Be used by external systems to drive authorization decisions as this raises confused deputy, cache lifetime/revocation, and correctness concerns. SubjectAccessReview, and LocalAccessReview are the correct way to defer authorization decisions to the API server. + * @export + * @interface V1SelfSubjectRulesReview + */ +export interface V1SelfSubjectRulesReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1SelfSubjectRulesReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1SelfSubjectRulesReview + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1SelfSubjectRulesReview + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1SelfSubjectRulesReviewSpec} + * @memberof V1SelfSubjectRulesReview + */ + spec: V1SelfSubjectRulesReviewSpec; + /** + * + * @type {V1SubjectRulesReviewStatus} + * @memberof V1SelfSubjectRulesReview + */ + status?: V1SubjectRulesReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SelfSubjectRulesReviewSpec.ts b/frontend/packages/kube-types/src/openshift/V1SelfSubjectRulesReviewSpec.ts new file mode 100644 index 00000000000..3261a5a9362 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SelfSubjectRulesReviewSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1SelfSubjectRulesReviewSpec + */ +export interface V1SelfSubjectRulesReviewSpec { + /** + * Namespace to evaluate rules for. Required. + * @type {string} + * @memberof V1SelfSubjectRulesReviewSpec + */ + namespace?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ServerAddressByClientCIDR.ts b/frontend/packages/kube-types/src/openshift/V1ServerAddressByClientCIDR.ts new file mode 100644 index 00000000000..f9545c5d53c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ServerAddressByClientCIDR.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match. + * @export + * @interface V1ServerAddressByClientCIDR + */ +export interface V1ServerAddressByClientCIDR { + /** + * The CIDR with which clients can match their IP to figure out the server address that they should use. + * @type {string} + * @memberof V1ServerAddressByClientCIDR + */ + clientCIDR: string; + /** + * Address of this server, suitable for a client that matches the above CIDR. This can be a hostname, hostname:port, IP or IP:port. + * @type {string} + * @memberof V1ServerAddressByClientCIDR + */ + serverAddress: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Service.ts b/frontend/packages/kube-types/src/openshift/V1Service.ts new file mode 100644 index 00000000000..63f8ab80d4b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Service.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ServiceSpec } from './V1ServiceSpec'; +import { V1ServiceStatus } from './V1ServiceStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Service is a named abstraction of software service (for example, mysql) consisting of local port (for example 3306) that the proxy listens on, and the selector that determines which pods will answer requests sent through the proxy. + * @export + * @interface V1Service + */ +export interface V1Service { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Service + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Service + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Service + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1ServiceSpec} + * @memberof V1Service + */ + spec?: V1ServiceSpec; + /** + * + * @type {V1ServiceStatus} + * @memberof V1Service + */ + status?: V1ServiceStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ServiceAccount.ts b/frontend/packages/kube-types/src/openshift/V1ServiceAccount.ts new file mode 100644 index 00000000000..30229172467 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ServiceAccount.ts @@ -0,0 +1,60 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; +import { V1ObjectReference } from './V1ObjectReference'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ServiceAccount binds together: * a name, understood by users, and perhaps by peripheral systems, for an identity * a principal that can be authenticated and authorized * a set of secrets + * @export + * @interface V1ServiceAccount + */ +export interface V1ServiceAccount { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ServiceAccount + */ + apiVersion?: string; + /** + * AutomountServiceAccountToken indicates whether pods running as this service account should have an API token automatically mounted. Can be overridden at the pod level. + * @type {boolean} + * @memberof V1ServiceAccount + */ + automountServiceAccountToken?: boolean; + /** + * ImagePullSecrets is a list of references to secrets in the same namespace to use for pulling any images in pods that reference this ServiceAccount. ImagePullSecrets are distinct from Secrets because Secrets can be mounted in the pod, but ImagePullSecrets are only accessed by the kubelet. More info: https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod + * @type {Array} + * @memberof V1ServiceAccount + */ + imagePullSecrets?: V1LocalObjectReference[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ServiceAccount + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1ServiceAccount + */ + metadata?: V1ObjectMeta; + /** + * Secrets is the list of secrets allowed to be used by pods running using this ServiceAccount. More info: https://kubernetes.io/docs/concepts/configuration/secret + * @type {Array} + * @memberof V1ServiceAccount + */ + secrets?: V1ObjectReference[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ServiceAccountList.ts b/frontend/packages/kube-types/src/openshift/V1ServiceAccountList.ts new file mode 100644 index 00000000000..194eff4a144 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ServiceAccountList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ServiceAccount } from './V1ServiceAccount'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ServiceAccountList is a list of ServiceAccount objects + * @export + * @interface V1ServiceAccountList + */ +export interface V1ServiceAccountList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ServiceAccountList + */ + apiVersion?: string; + /** + * List of ServiceAccounts. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/ + * @type {Array} + * @memberof V1ServiceAccountList + */ + items: V1ServiceAccount[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ServiceAccountList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1ServiceAccountList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ServiceAccountTokenProjection.ts b/frontend/packages/kube-types/src/openshift/V1ServiceAccountTokenProjection.ts new file mode 100644 index 00000000000..be03a37fb00 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ServiceAccountTokenProjection.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ServiceAccountTokenProjection represents a projected service account token volume. This projection can be used to insert a service account token into the pods runtime filesystem for use against APIs (Kubernetes API Server or otherwise). + * @export + * @interface V1ServiceAccountTokenProjection + */ +export interface V1ServiceAccountTokenProjection { + /** + * Audience is the intended audience of the token. A recipient of a token must identify itself with an identifier specified in the audience of the token, and otherwise should reject the token. The audience defaults to the identifier of the apiserver. + * @type {string} + * @memberof V1ServiceAccountTokenProjection + */ + audience?: string; + /** + * ExpirationSeconds is the requested duration of validity of the service account token. As the token approaches expiration, the kubelet volume plugin will proactively rotate the service account token. The kubelet will start trying to rotate the token if the token is older than 80 percent of its time to live or if the token is older than 24 hours.Defaults to 1 hour and must be at least 10 minutes. + * @type {number} + * @memberof V1ServiceAccountTokenProjection + */ + expirationSeconds?: number; + /** + * Path is the path relative to the mount point of the file to project the token into. + * @type {string} + * @memberof V1ServiceAccountTokenProjection + */ + path: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ServiceList.ts b/frontend/packages/kube-types/src/openshift/V1ServiceList.ts new file mode 100644 index 00000000000..94e5fcbe20e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ServiceList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Service } from './V1Service'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ServiceList holds a list of services. + * @export + * @interface V1ServiceList + */ +export interface V1ServiceList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1ServiceList + */ + apiVersion?: string; + /** + * List of services + * @type {Array} + * @memberof V1ServiceList + */ + items: V1Service[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1ServiceList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1ServiceList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ServicePort.ts b/frontend/packages/kube-types/src/openshift/V1ServicePort.ts new file mode 100644 index 00000000000..3a2cacf642a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ServicePort.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ServicePort contains information on service\'s port. + * @export + * @interface V1ServicePort + */ +export interface V1ServicePort { + /** + * The name of this port within the service. This must be a DNS_LABEL. All ports within a ServiceSpec must have unique names. This maps to the \'Name\' field in EndpointPort objects. Optional if only one ServicePort is defined on this service. + * @type {string} + * @memberof V1ServicePort + */ + name?: string; + /** + * The port on each node on which this service is exposed when type=NodePort or LoadBalancer. Usually assigned by the system. If specified, it will be allocated to the service if unused or else creation of the service will fail. Default is to auto-allocate a port if the ServiceType of this Service requires one. More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport + * @type {number} + * @memberof V1ServicePort + */ + nodePort?: number; + /** + * The port that will be exposed by this service. + * @type {number} + * @memberof V1ServicePort + */ + port: number; + /** + * The IP protocol for this port. Supports \"TCP\" and \"UDP\". Default is TCP. + * @type {string} + * @memberof V1ServicePort + */ + protocol?: string; + /** + * + * @type {string} + * @memberof V1ServicePort + */ + targetPort?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ServiceSpec.ts b/frontend/packages/kube-types/src/openshift/V1ServiceSpec.ts new file mode 100644 index 00000000000..a67236cd7b9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ServiceSpec.ts @@ -0,0 +1,101 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ServicePort } from './V1ServicePort'; +import { V1SessionAffinityConfig } from './V1SessionAffinityConfig'; + +/** + * ServiceSpec describes the attributes that a user creates on a service. + * @export + * @interface V1ServiceSpec + */ +export interface V1ServiceSpec { + /** + * clusterIP is the IP address of the service and is usually assigned randomly by the master. If an address is specified manually and is not in use by others, it will be allocated to the service; otherwise, creation of the service will fail. This field can not be changed through updates. Valid values are \"None\", empty string (\"\"), or a valid IP address. \"None\" can be specified for headless services when proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies + * @type {string} + * @memberof V1ServiceSpec + */ + clusterIP?: string; + /** + * externalIPs is a list of IP addresses for which nodes in the cluster will also accept traffic for this service. These IPs are not managed by Kubernetes. The user is responsible for ensuring that traffic arrives at a node with this IP. A common example is external load-balancers that are not part of the Kubernetes system. + * @type {Array} + * @memberof V1ServiceSpec + */ + externalIPs?: string[]; + /** + * externalName is the external reference that kubedns or equivalent will return as a CNAME record for this service. No proxying will be involved. Must be a valid RFC-1123 hostname (https://tools.ietf.org/html/rfc1123) and requires Type to be ExternalName. + * @type {string} + * @memberof V1ServiceSpec + */ + externalName?: string; + /** + * externalTrafficPolicy denotes if this Service desires to route external traffic to node-local or cluster-wide endpoints. \"Local\" preserves the client source IP and avoids a second hop for LoadBalancer and Nodeport type services, but risks potentially imbalanced traffic spreading. \"Cluster\" obscures the client source IP and may cause a second hop to another node, but should have good overall load-spreading. + * @type {string} + * @memberof V1ServiceSpec + */ + externalTrafficPolicy?: string; + /** + * healthCheckNodePort specifies the healthcheck nodePort for the service. If not specified, HealthCheckNodePort is created by the service api backend with the allocated nodePort. Will use user-specified nodePort value if specified by the client. Only effects when Type is set to LoadBalancer and ExternalTrafficPolicy is set to Local. + * @type {number} + * @memberof V1ServiceSpec + */ + healthCheckNodePort?: number; + /** + * Only applies to Service Type: LoadBalancer LoadBalancer will get created with the IP specified in this field. This feature depends on whether the underlying cloud-provider supports specifying the loadBalancerIP when a load balancer is created. This field will be ignored if the cloud-provider does not support the feature. + * @type {string} + * @memberof V1ServiceSpec + */ + loadBalancerIP?: string; + /** + * If specified and supported by the platform, this will restrict traffic through the cloud-provider load-balancer will be restricted to the specified client IPs. This field will be ignored if the cloud-provider does not support the feature.\" More info: https://kubernetes.io/docs/tasks/access-application-cluster/configure-cloud-provider-firewall/ + * @type {Array} + * @memberof V1ServiceSpec + */ + loadBalancerSourceRanges?: string[]; + /** + * The list of ports that are exposed by this service. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies + * @type {Array} + * @memberof V1ServiceSpec + */ + ports?: V1ServicePort[]; + /** + * publishNotReadyAddresses, when set to true, indicates that DNS implementations must publish the notReadyAddresses of subsets for the Endpoints associated with the Service. The default value is false. The primary use case for setting this field is to use a StatefulSet\'s Headless Service to propagate SRV records for its Pods without respect to their readiness for purpose of peer discovery. + * @type {boolean} + * @memberof V1ServiceSpec + */ + publishNotReadyAddresses?: boolean; + /** + * Route service traffic to pods with label keys and values matching this selector. If empty or not present, the service is assumed to have an external process managing its endpoints, which Kubernetes will not modify. Only applies to types ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/ + * @type {{ [key: string]: string; }} + * @memberof V1ServiceSpec + */ + selector?: { [key: string]: string }; + /** + * Supports \"ClientIP\" and \"None\". Used to maintain session affinity. Enable client IP based session affinity. Must be ClientIP or None. Defaults to None. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies + * @type {string} + * @memberof V1ServiceSpec + */ + sessionAffinity?: string; + /** + * + * @type {V1SessionAffinityConfig} + * @memberof V1ServiceSpec + */ + sessionAffinityConfig?: V1SessionAffinityConfig; + /** + * type determines how the Service is exposed. Defaults to ClusterIP. Valid options are ExternalName, ClusterIP, NodePort, and LoadBalancer. \"ExternalName\" maps to the specified externalName. \"ClusterIP\" allocates a cluster-internal IP address for load-balancing to endpoints. Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object. If clusterIP is \"None\", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a stable IP. \"NodePort\" builds on ClusterIP and allocates a port on every node which routes to the clusterIP. \"LoadBalancer\" builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the clusterIP. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services---service-types + * @type {string} + * @memberof V1ServiceSpec + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1ServiceStatus.ts b/frontend/packages/kube-types/src/openshift/V1ServiceStatus.ts new file mode 100644 index 00000000000..7246488fe29 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1ServiceStatus.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LoadBalancerStatus } from './V1LoadBalancerStatus'; + +/** + * ServiceStatus represents the current status of a service. + * @export + * @interface V1ServiceStatus + */ +export interface V1ServiceStatus { + /** + * + * @type {V1LoadBalancerStatus} + * @memberof V1ServiceStatus + */ + loadBalancer?: V1LoadBalancerStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SessionAffinityConfig.ts b/frontend/packages/kube-types/src/openshift/V1SessionAffinityConfig.ts new file mode 100644 index 00000000000..5380f5f478f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SessionAffinityConfig.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ClientIPConfig } from './V1ClientIPConfig'; + +/** + * SessionAffinityConfig represents the configurations of session affinity. + * @export + * @interface V1SessionAffinityConfig + */ +export interface V1SessionAffinityConfig { + /** + * + * @type {V1ClientIPConfig} + * @memberof V1SessionAffinityConfig + */ + clientIP?: V1ClientIPConfig; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StatefulSet.ts b/frontend/packages/kube-types/src/openshift/V1StatefulSet.ts new file mode 100644 index 00000000000..89b38ff271c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StatefulSet.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1StatefulSetSpec } from './V1StatefulSetSpec'; +import { V1StatefulSetStatus } from './V1StatefulSetStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * StatefulSet represents a set of pods with consistent identities. Identities are defined as: - Network: A single stable DNS and hostname. - Storage: As many VolumeClaims as requested. The StatefulSet guarantees that a given network identity will always map to the same storage identity. + * @export + * @interface V1StatefulSet + */ +export interface V1StatefulSet { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1StatefulSet + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1StatefulSet + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1StatefulSet + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1StatefulSetSpec} + * @memberof V1StatefulSet + */ + spec?: V1StatefulSetSpec; + /** + * + * @type {V1StatefulSetStatus} + * @memberof V1StatefulSet + */ + status?: V1StatefulSetStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StatefulSetCondition.ts b/frontend/packages/kube-types/src/openshift/V1StatefulSetCondition.ts new file mode 100644 index 00000000000..805ecab3edf --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StatefulSetCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * StatefulSetCondition describes the state of a statefulset at a certain point. + * @export + * @interface V1StatefulSetCondition + */ +export interface V1StatefulSetCondition { + /** + * + * @type {string} + * @memberof V1StatefulSetCondition + */ + lastTransitionTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof V1StatefulSetCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof V1StatefulSetCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1StatefulSetCondition + */ + status: string; + /** + * Type of statefulset condition. + * @type {string} + * @memberof V1StatefulSetCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StatefulSetList.ts b/frontend/packages/kube-types/src/openshift/V1StatefulSetList.ts new file mode 100644 index 00000000000..b114b05b4a9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StatefulSetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1StatefulSet } from './V1StatefulSet'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * StatefulSetList is a collection of StatefulSets. + * @export + * @interface V1StatefulSetList + */ +export interface V1StatefulSetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1StatefulSetList + */ + apiVersion?: string; + /** + * + * @type {Array} + * @memberof V1StatefulSetList + */ + items: V1StatefulSet[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1StatefulSetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1StatefulSetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StatefulSetSpec.ts b/frontend/packages/kube-types/src/openshift/V1StatefulSetSpec.ts new file mode 100644 index 00000000000..289bbe876e2 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StatefulSetSpec.ts @@ -0,0 +1,73 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1StatefulSetUpdateStrategy } from './V1StatefulSetUpdateStrategy'; +import { V1PersistentVolumeClaim } from './V1PersistentVolumeClaim'; +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * A StatefulSetSpec is the specification of a StatefulSet. + * @export + * @interface V1StatefulSetSpec + */ +export interface V1StatefulSetSpec { + /** + * podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once. + * @type {string} + * @memberof V1StatefulSetSpec + */ + podManagementPolicy?: string; + /** + * replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1. + * @type {number} + * @memberof V1StatefulSetSpec + */ + replicas?: number; + /** + * revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet\'s revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10. + * @type {number} + * @memberof V1StatefulSetSpec + */ + revisionHistoryLimit?: number; + /** + * + * @type {V1LabelSelector} + * @memberof V1StatefulSetSpec + */ + selector: V1LabelSelector; + /** + * serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller. + * @type {string} + * @memberof V1StatefulSetSpec + */ + serviceName: string; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1StatefulSetSpec + */ + template: V1PodTemplateSpec; + /** + * + * @type {V1StatefulSetUpdateStrategy} + * @memberof V1StatefulSetSpec + */ + updateStrategy?: V1StatefulSetUpdateStrategy; + /** + * volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name. + * @type {Array} + * @memberof V1StatefulSetSpec + */ + volumeClaimTemplates?: V1PersistentVolumeClaim[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StatefulSetStatus.ts b/frontend/packages/kube-types/src/openshift/V1StatefulSetStatus.ts new file mode 100644 index 00000000000..b4ffe044299 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StatefulSetStatus.ts @@ -0,0 +1,76 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1StatefulSetCondition } from './V1StatefulSetCondition'; + +/** + * StatefulSetStatus represents the current state of a StatefulSet. + * @export + * @interface V1StatefulSetStatus + */ +export interface V1StatefulSetStatus { + /** + * collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. + * @type {number} + * @memberof V1StatefulSetStatus + */ + collisionCount?: number; + /** + * Represents the latest available observations of a statefulset\'s current state. + * @type {Array} + * @memberof V1StatefulSetStatus + */ + conditions?: V1StatefulSetCondition[]; + /** + * currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision. + * @type {number} + * @memberof V1StatefulSetStatus + */ + currentReplicas?: number; + /** + * currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas). + * @type {string} + * @memberof V1StatefulSetStatus + */ + currentRevision?: string; + /** + * observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet\'s generation, which is updated on mutation by the API Server. + * @type {number} + * @memberof V1StatefulSetStatus + */ + observedGeneration?: number; + /** + * readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. + * @type {number} + * @memberof V1StatefulSetStatus + */ + readyReplicas?: number; + /** + * replicas is the number of Pods created by the StatefulSet controller. + * @type {number} + * @memberof V1StatefulSetStatus + */ + replicas: number; + /** + * updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas) + * @type {string} + * @memberof V1StatefulSetStatus + */ + updateRevision?: string; + /** + * updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision. + * @type {number} + * @memberof V1StatefulSetStatus + */ + updatedReplicas?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StatefulSetUpdateStrategy.ts b/frontend/packages/kube-types/src/openshift/V1StatefulSetUpdateStrategy.ts new file mode 100644 index 00000000000..5cac5f39a51 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StatefulSetUpdateStrategy.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1RollingUpdateStatefulSetStrategy } from './V1RollingUpdateStatefulSetStrategy'; + +/** + * StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. + * @export + * @interface V1StatefulSetUpdateStrategy + */ +export interface V1StatefulSetUpdateStrategy { + /** + * + * @type {V1RollingUpdateStatefulSetStrategy} + * @memberof V1StatefulSetUpdateStrategy + */ + rollingUpdate?: V1RollingUpdateStatefulSetStrategy; + /** + * Type indicates the type of the StatefulSetUpdateStrategy. Default is RollingUpdate. + * @type {string} + * @memberof V1StatefulSetUpdateStrategy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Status.ts b/frontend/packages/kube-types/src/openshift/V1Status.ts new file mode 100644 index 00000000000..330e61f5a77 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Status.ts @@ -0,0 +1,71 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ListMeta } from './V1ListMeta'; +import { V1StatusDetails } from './V1StatusDetails'; + +/** + * Status is a return value for calls that don\'t return other objects. + * @export + * @interface V1Status + */ +export interface V1Status { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Status + */ + apiVersion?: string; + /** + * Suggested HTTP return code for this status, 0 if not set. + * @type {number} + * @memberof V1Status + */ + code?: number; + /** + * + * @type {V1StatusDetails} + * @memberof V1Status + */ + details?: V1StatusDetails; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Status + */ + kind?: string; + /** + * A human-readable description of the status of this operation. + * @type {string} + * @memberof V1Status + */ + message?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1Status + */ + metadata?: V1ListMeta; + /** + * A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it. + * @type {string} + * @memberof V1Status + */ + reason?: string; + /** + * Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status + * @type {string} + * @memberof V1Status + */ + status?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StatusCause.ts b/frontend/packages/kube-types/src/openshift/V1StatusCause.ts new file mode 100644 index 00000000000..17c63da2196 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StatusCause.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered. + * @export + * @interface V1StatusCause + */ +export interface V1StatusCause { + /** + * The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional. Examples: \"name\" - the field \"name\" on the current resource \"items[0].name\" - the field \"name\" on the first array entry in \"items\" + * @type {string} + * @memberof V1StatusCause + */ + field?: string; + /** + * A human-readable description of the cause of the error. This field may be presented as-is to a reader. + * @type {string} + * @memberof V1StatusCause + */ + message?: string; + /** + * A machine-readable description of the cause of the error. If this value is empty there is no information available. + * @type {string} + * @memberof V1StatusCause + */ + reason?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StatusDetails.ts b/frontend/packages/kube-types/src/openshift/V1StatusDetails.ts new file mode 100644 index 00000000000..a3bc2a1becd --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StatusDetails.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1StatusCause } from './V1StatusCause'; + +/** + * StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined. + * @export + * @interface V1StatusDetails + */ +export interface V1StatusDetails { + /** + * The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes. + * @type {Array} + * @memberof V1StatusDetails + */ + causes?: V1StatusCause[]; + /** + * The group attribute of the resource associated with the status StatusReason. + * @type {string} + * @memberof V1StatusDetails + */ + group?: string; + /** + * The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1StatusDetails + */ + kind?: string; + /** + * The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described). + * @type {string} + * @memberof V1StatusDetails + */ + name?: string; + /** + * If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action. + * @type {number} + * @memberof V1StatusDetails + */ + retryAfterSeconds?: number; + /** + * UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids + * @type {string} + * @memberof V1StatusDetails + */ + uid?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StorageClass.ts b/frontend/packages/kube-types/src/openshift/V1StorageClass.ts new file mode 100644 index 00000000000..80aadc1f568 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StorageClass.ts @@ -0,0 +1,83 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1TopologySelectorTerm } from './V1TopologySelectorTerm'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned. StorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name. + * @export + * @interface V1StorageClass + */ +export interface V1StorageClass { + /** + * AllowVolumeExpansion shows whether the storage class allow volume expand + * @type {boolean} + * @memberof V1StorageClass + */ + allowVolumeExpansion?: boolean; + /** + * Restrict the node topologies where volumes can be dynamically provisioned. Each volume plugin defines its own supported topology specifications. An empty TopologySelectorTerm list means there is no topology restriction. This field is alpha-level and is only honored by servers that enable the DynamicProvisioningScheduling feature. + * @type {Array} + * @memberof V1StorageClass + */ + allowedTopologies?: V1TopologySelectorTerm[]; + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1StorageClass + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1StorageClass + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1StorageClass + */ + metadata?: V1ObjectMeta; + /** + * Dynamically provisioned PersistentVolumes of this storage class are created with these mountOptions, e.g. [\"ro\", \"soft\"]. Not validated - mount of the PVs will simply fail if one is invalid. + * @type {Array} + * @memberof V1StorageClass + */ + mountOptions?: string[]; + /** + * Parameters holds the parameters for the provisioner that should create volumes of this storage class. + * @type {{ [key: string]: string; }} + * @memberof V1StorageClass + */ + parameters?: { [key: string]: string }; + /** + * Provisioner indicates the type of the provisioner. + * @type {string} + * @memberof V1StorageClass + */ + provisioner: string; + /** + * Dynamically provisioned PersistentVolumes of this storage class are created with this reclaimPolicy. Defaults to Delete. + * @type {string} + * @memberof V1StorageClass + */ + reclaimPolicy?: string; + /** + * VolumeBindingMode indicates how PersistentVolumeClaims should be provisioned and bound. When unset, VolumeBindingImmediate is used. This field is alpha-level and is only honored by servers that enable the VolumeScheduling feature. + * @type {string} + * @memberof V1StorageClass + */ + volumeBindingMode?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StorageClassList.ts b/frontend/packages/kube-types/src/openshift/V1StorageClassList.ts new file mode 100644 index 00000000000..bb8330b52cc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StorageClassList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1StorageClass } from './V1StorageClass'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * StorageClassList is a collection of storage classes. + * @export + * @interface V1StorageClassList + */ +export interface V1StorageClassList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1StorageClassList + */ + apiVersion?: string; + /** + * Items is the list of StorageClasses + * @type {Array} + * @memberof V1StorageClassList + */ + items: V1StorageClass[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1StorageClassList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1StorageClassList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StorageOSPersistentVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1StorageOSPersistentVolumeSource.ts new file mode 100644 index 00000000000..ea4b9c56279 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StorageOSPersistentVolumeSource.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * Represents a StorageOS persistent volume resource. + * @export + * @interface V1StorageOSPersistentVolumeSource + */ +export interface V1StorageOSPersistentVolumeSource { + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. + * @type {string} + * @memberof V1StorageOSPersistentVolumeSource + */ + fsType?: string; + /** + * Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. + * @type {boolean} + * @memberof V1StorageOSPersistentVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1ObjectReference} + * @memberof V1StorageOSPersistentVolumeSource + */ + secretRef?: V1ObjectReference; + /** + * VolumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace. + * @type {string} + * @memberof V1StorageOSPersistentVolumeSource + */ + volumeName?: string; + /** + * VolumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod\'s namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created. + * @type {string} + * @memberof V1StorageOSPersistentVolumeSource + */ + volumeNamespace?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1StorageOSVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1StorageOSVolumeSource.ts new file mode 100644 index 00000000000..36e08e57fed --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1StorageOSVolumeSource.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * Represents a StorageOS persistent volume resource. + * @export + * @interface V1StorageOSVolumeSource + */ +export interface V1StorageOSVolumeSource { + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. + * @type {string} + * @memberof V1StorageOSVolumeSource + */ + fsType?: string; + /** + * Defaults to false (read/write). ReadOnly here will force the ReadOnly setting in VolumeMounts. + * @type {boolean} + * @memberof V1StorageOSVolumeSource + */ + readOnly?: boolean; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1StorageOSVolumeSource + */ + secretRef?: V1LocalObjectReference; + /** + * VolumeName is the human-readable name of the StorageOS volume. Volume names are only unique within a namespace. + * @type {string} + * @memberof V1StorageOSVolumeSource + */ + volumeName?: string; + /** + * VolumeNamespace specifies the scope of the volume within StorageOS. If no namespace is specified then the Pod\'s namespace will be used. This allows the Kubernetes name scoping to be mirrored within StorageOS for tighter integration. Set VolumeName to any name to override the default behaviour. Set to \"default\" if you are not using namespaces within StorageOS. Namespaces that do not pre-exist within StorageOS will be created. + * @type {string} + * @memberof V1StorageOSVolumeSource + */ + volumeNamespace?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Subject.ts b/frontend/packages/kube-types/src/openshift/V1Subject.ts new file mode 100644 index 00000000000..5eda22169e8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Subject.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names. + * @export + * @interface V1Subject + */ +export interface V1Subject { + /** + * APIGroup holds the API group of the referenced subject. Defaults to \"\" for ServiceAccount subjects. Defaults to \"rbac.authorization.k8s.io\" for User and Group subjects. + * @type {string} + * @memberof V1Subject + */ + apiGroup?: string; + /** + * Kind of object being referenced. Values defined by this API group are \"User\", \"Group\", and \"ServiceAccount\". If the Authorizer does not recognized the kind value, the Authorizer should report an error. + * @type {string} + * @memberof V1Subject + */ + kind: string; + /** + * Name of the object being referenced. + * @type {string} + * @memberof V1Subject + */ + name: string; + /** + * Namespace of the referenced object. If the object kind is non-namespace, such as \"User\" or \"Group\", and this value is not empty the Authorizer should report an error. + * @type {string} + * @memberof V1Subject + */ + namespace?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SubjectAccessReview.ts b/frontend/packages/kube-types/src/openshift/V1SubjectAccessReview.ts new file mode 100644 index 00000000000..fcdabb3fe59 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SubjectAccessReview.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SubjectAccessReviewSpec } from './V1SubjectAccessReviewSpec'; +import { V1SubjectAccessReviewStatus } from './V1SubjectAccessReviewStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * SubjectAccessReview checks whether or not a user or group can perform an action. + * @export + * @interface V1SubjectAccessReview + */ +export interface V1SubjectAccessReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1SubjectAccessReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1SubjectAccessReview + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1SubjectAccessReview + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1SubjectAccessReviewSpec} + * @memberof V1SubjectAccessReview + */ + spec: V1SubjectAccessReviewSpec; + /** + * + * @type {V1SubjectAccessReviewStatus} + * @memberof V1SubjectAccessReview + */ + status?: V1SubjectAccessReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SubjectAccessReviewSpec.ts b/frontend/packages/kube-types/src/openshift/V1SubjectAccessReviewSpec.ts new file mode 100644 index 00000000000..40a95108213 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SubjectAccessReviewSpec.ts @@ -0,0 +1,59 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NonResourceAttributes } from './V1NonResourceAttributes'; +import { V1ResourceAttributes } from './V1ResourceAttributes'; + +/** + * SubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set + * @export + * @interface V1SubjectAccessReviewSpec + */ +export interface V1SubjectAccessReviewSpec { + /** + * Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here. + * @type {{ [key: string]: Array; }} + * @memberof V1SubjectAccessReviewSpec + */ + extra?: { [key: string]: string[] }; + /** + * Groups is the groups you\'re testing for. + * @type {Array} + * @memberof V1SubjectAccessReviewSpec + */ + groups?: string[]; + /** + * + * @type {V1NonResourceAttributes} + * @memberof V1SubjectAccessReviewSpec + */ + nonResourceAttributes?: V1NonResourceAttributes; + /** + * + * @type {V1ResourceAttributes} + * @memberof V1SubjectAccessReviewSpec + */ + resourceAttributes?: V1ResourceAttributes; + /** + * UID information about the requesting user. + * @type {string} + * @memberof V1SubjectAccessReviewSpec + */ + uid?: string; + /** + * User is the user you\'re testing for. If you specify \"User\" but not \"Groups\", then is it interpreted as \"What if User were not a member of any groups + * @type {string} + * @memberof V1SubjectAccessReviewSpec + */ + user?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SubjectAccessReviewStatus.ts b/frontend/packages/kube-types/src/openshift/V1SubjectAccessReviewStatus.ts new file mode 100644 index 00000000000..f8c4093b4fa --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SubjectAccessReviewStatus.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SubjectAccessReviewStatus + * @export + * @interface V1SubjectAccessReviewStatus + */ +export interface V1SubjectAccessReviewStatus { + /** + * Allowed is required. True if the action would be allowed, false otherwise. + * @type {boolean} + * @memberof V1SubjectAccessReviewStatus + */ + allowed: boolean; + /** + * Denied is optional. True if the action would be denied, otherwise false. If both allowed is false and denied is false, then the authorizer has no opinion on whether to authorize the action. Denied may not be true if Allowed is true. + * @type {boolean} + * @memberof V1SubjectAccessReviewStatus + */ + denied?: boolean; + /** + * EvaluationError is an indication that some error occurred during the authorization check. It is entirely possible to get an error and be able to continue determine authorization status in spite of it. For instance, RBAC can be missing a role, but enough roles are still present and bound to reason about the request. + * @type {string} + * @memberof V1SubjectAccessReviewStatus + */ + evaluationError?: string; + /** + * Reason is optional. It indicates why a request was allowed or denied. + * @type {string} + * @memberof V1SubjectAccessReviewStatus + */ + reason?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1SubjectRulesReviewStatus.ts b/frontend/packages/kube-types/src/openshift/V1SubjectRulesReviewStatus.ts new file mode 100644 index 00000000000..20ee32913d0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1SubjectRulesReviewStatus.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NonResourceRule } from './V1NonResourceRule'; +import { V1ResourceRule } from './V1ResourceRule'; + +/** + * SubjectRulesReviewStatus contains the result of a rules check. This check can be incomplete depending on the set of authorizers the server is configured with and any errors experienced during evaluation. Because authorization rules are additive, if a rule appears in a list it\'s safe to assume the subject has that permission, even if that list is incomplete. + * @export + * @interface V1SubjectRulesReviewStatus + */ +export interface V1SubjectRulesReviewStatus { + /** + * EvaluationError can appear in combination with Rules. It indicates an error occurred during rule evaluation, such as an authorizer that doesn\'t support rule evaluation, and that ResourceRules and/or NonResourceRules may be incomplete. + * @type {string} + * @memberof V1SubjectRulesReviewStatus + */ + evaluationError?: string; + /** + * Incomplete is true when the rules returned by this call are incomplete. This is most commonly encountered when an authorizer, such as an external authorizer, doesn\'t support rules evaluation. + * @type {boolean} + * @memberof V1SubjectRulesReviewStatus + */ + incomplete: boolean; + /** + * NonResourceRules is the list of actions the subject is allowed to perform on non-resources. The list ordering isn\'t significant, may contain duplicates, and possibly be incomplete. + * @type {Array} + * @memberof V1SubjectRulesReviewStatus + */ + nonResourceRules: V1NonResourceRule[]; + /** + * ResourceRules is the list of actions the subject is allowed to perform on resources. The list ordering isn\'t significant, may contain duplicates, and possibly be incomplete. + * @type {Array} + * @memberof V1SubjectRulesReviewStatus + */ + resourceRules: V1ResourceRule[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Sysctl.ts b/frontend/packages/kube-types/src/openshift/V1Sysctl.ts new file mode 100644 index 00000000000..0e98f368e3f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Sysctl.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Sysctl defines a kernel parameter to be set + * @export + * @interface V1Sysctl + */ +export interface V1Sysctl { + /** + * Name of a property to set + * @type {string} + * @memberof V1Sysctl + */ + name: string; + /** + * Value of a property to set + * @type {string} + * @memberof V1Sysctl + */ + value: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TCPSocketAction.ts b/frontend/packages/kube-types/src/openshift/V1TCPSocketAction.ts new file mode 100644 index 00000000000..9a763fbbe77 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TCPSocketAction.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TCPSocketAction describes an action based on opening a socket + * @export + * @interface V1TCPSocketAction + */ +export interface V1TCPSocketAction { + /** + * Optional: Host name to connect to, defaults to the pod IP. + * @type {string} + * @memberof V1TCPSocketAction + */ + host?: string; + /** + * + * @type {string} + * @memberof V1TCPSocketAction + */ + port: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TLSConfig.ts b/frontend/packages/kube-types/src/openshift/V1TLSConfig.ts new file mode 100644 index 00000000000..e409acb659a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TLSConfig.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TLSConfig defines config used to secure a route and provide termination + * @export + * @interface V1TLSConfig + */ +export interface V1TLSConfig { + /** + * caCertificate provides the cert authority certificate contents + * @type {string} + * @memberof V1TLSConfig + */ + caCertificate?: string; + /** + * certificate provides certificate contents + * @type {string} + * @memberof V1TLSConfig + */ + certificate?: string; + /** + * destinationCACertificate provides the contents of the ca certificate of the final destination. When using reencrypt termination this file should be provided in order to have routers use it for health checks on the secure connection. If this field is not specified, the router may provide its own destination CA and perform hostname validation using the short service name (service.namespace.svc), which allows infrastructure generated certificates to automatically verify. + * @type {string} + * @memberof V1TLSConfig + */ + destinationCACertificate?: string; + /** + * insecureEdgeTerminationPolicy indicates the desired behavior for insecure connections to a route. While each router may make its own decisions on which ports to expose, this is normally port 80. * Allow - traffic is sent to the server on the insecure port (default) * Disable - no traffic is allowed on the insecure port. * Redirect - clients are redirected to the secure port. + * @type {string} + * @memberof V1TLSConfig + */ + insecureEdgeTerminationPolicy?: string; + /** + * key provides key file contents + * @type {string} + * @memberof V1TLSConfig + */ + key?: string; + /** + * termination indicates termination type. + * @type {string} + * @memberof V1TLSConfig + */ + termination: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Taint.ts b/frontend/packages/kube-types/src/openshift/V1Taint.ts new file mode 100644 index 00000000000..74a87dfb170 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Taint.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * The node this Taint is attached to has the \"effect\" on any pod that does not tolerate the Taint. + * @export + * @interface V1Taint + */ +export interface V1Taint { + /** + * Required. The effect of the taint on pods that do not tolerate the taint. Valid effects are NoSchedule, PreferNoSchedule and NoExecute. + * @type {string} + * @memberof V1Taint + */ + effect: string; + /** + * Required. The taint key to be applied to a node. + * @type {string} + * @memberof V1Taint + */ + key: string; + /** + * + * @type {string} + * @memberof V1Taint + */ + timeAdded?: string; + /** + * Required. The taint value corresponding to the taint key. + * @type {string} + * @memberof V1Taint + */ + value?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Template.ts b/frontend/packages/kube-types/src/openshift/V1Template.ts new file mode 100644 index 00000000000..e55cc3a2b36 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Template.ts @@ -0,0 +1,66 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Parameter } from './V1Parameter'; +import { V1ObjectMeta } from './V1ObjectMeta'; +import { IoK8sApimachineryPkgRuntimeRawExtension } from './IoK8sApimachineryPkgRuntimeRawExtension'; + +/** + * Template contains the inputs needed to produce a Config. + * @export + * @interface V1Template + */ +export interface V1Template { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Template + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Template + */ + kind?: string; + /** + * labels is a optional set of labels that are applied to every object during the Template to Config transformation. + * @type {{ [key: string]: string; }} + * @memberof V1Template + */ + labels?: { [key: string]: string }; + /** + * message is an optional instructional message that will be displayed when this template is instantiated. This field should inform the user how to utilize the newly created resources. Parameter substitution will be performed on the message before being displayed so that generated credentials and other parameters can be included in the output. + * @type {string} + * @memberof V1Template + */ + message?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1Template + */ + metadata?: V1ObjectMeta; + /** + * objects is an array of resources to include in this template. If a namespace value is hardcoded in the object, it will be removed during template instantiation, however if the namespace value is, or contains, a ${PARAMETER_REFERENCE}, the resolved value after parameter substitution will be respected and the object will be created in that namespace. + * @type {Array} + * @memberof V1Template + */ + objects: IoK8sApimachineryPkgRuntimeRawExtension[]; + /** + * parameters is an optional array of Parameters used during the Template to Config transformation. + * @type {Array} + * @memberof V1Template + */ + parameters?: V1Parameter[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TemplateInstance.ts b/frontend/packages/kube-types/src/openshift/V1TemplateInstance.ts new file mode 100644 index 00000000000..c19295403a5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TemplateInstance.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1TemplateInstanceSpec } from './V1TemplateInstanceSpec'; +import { V1TemplateInstanceStatus } from './V1TemplateInstanceStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * TemplateInstance requests and records the instantiation of a Template. TemplateInstance is part of an experimental API. + * @export + * @interface V1TemplateInstance + */ +export interface V1TemplateInstance { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1TemplateInstance + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1TemplateInstance + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1TemplateInstance + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1TemplateInstanceSpec} + * @memberof V1TemplateInstance + */ + spec: V1TemplateInstanceSpec; + /** + * + * @type {V1TemplateInstanceStatus} + * @memberof V1TemplateInstance + */ + status: V1TemplateInstanceStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TemplateInstanceCondition.ts b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceCondition.ts new file mode 100644 index 00000000000..9e0928cd022 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TemplateInstanceCondition contains condition information for a TemplateInstance. + * @export + * @interface V1TemplateInstanceCondition + */ +export interface V1TemplateInstanceCondition { + /** + * + * @type {string} + * @memberof V1TemplateInstanceCondition + */ + lastTransitionTime: string; + /** + * Message is a human readable description of the details of the last transition, complementing reason. + * @type {string} + * @memberof V1TemplateInstanceCondition + */ + message: string; + /** + * Reason is a brief machine readable explanation for the condition\'s last transition. + * @type {string} + * @memberof V1TemplateInstanceCondition + */ + reason: string; + /** + * Status of the condition, one of True, False or Unknown. + * @type {string} + * @memberof V1TemplateInstanceCondition + */ + status: string; + /** + * Type of the condition, currently Ready or InstantiateFailure. + * @type {string} + * @memberof V1TemplateInstanceCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TemplateInstanceList.ts b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceList.ts new file mode 100644 index 00000000000..6f96d11fb1a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1TemplateInstance } from './V1TemplateInstance'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * TemplateInstanceList is a list of TemplateInstance objects. + * @export + * @interface V1TemplateInstanceList + */ +export interface V1TemplateInstanceList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1TemplateInstanceList + */ + apiVersion?: string; + /** + * items is a list of Templateinstances + * @type {Array} + * @memberof V1TemplateInstanceList + */ + items: V1TemplateInstance[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1TemplateInstanceList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1TemplateInstanceList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TemplateInstanceObject.ts b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceObject.ts new file mode 100644 index 00000000000..22af472840b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceObject.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * TemplateInstanceObject references an object created by a TemplateInstance. + * @export + * @interface V1TemplateInstanceObject + */ +export interface V1TemplateInstanceObject { + /** + * + * @type {V1ObjectReference} + * @memberof V1TemplateInstanceObject + */ + ref?: V1ObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TemplateInstanceRequester.ts b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceRequester.ts new file mode 100644 index 00000000000..e4fc6200802 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceRequester.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TemplateInstanceRequester holds the identity of an agent requesting a template instantiation. + * @export + * @interface V1TemplateInstanceRequester + */ +export interface V1TemplateInstanceRequester { + /** + * extra holds additional information provided by the authenticator. + * @type {{ [key: string]: Array; }} + * @memberof V1TemplateInstanceRequester + */ + extra?: { [key: string]: string[] }; + /** + * groups represent the groups this user is a part of. + * @type {Array} + * @memberof V1TemplateInstanceRequester + */ + groups?: string[]; + /** + * uid is a unique value that identifies this user across time; if this user is deleted and another user by the same name is added, they will have different UIDs. + * @type {string} + * @memberof V1TemplateInstanceRequester + */ + uid?: string; + /** + * username uniquely identifies this user among all active users. + * @type {string} + * @memberof V1TemplateInstanceRequester + */ + username?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TemplateInstanceSpec.ts b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceSpec.ts new file mode 100644 index 00000000000..cbaad9c5935 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceSpec.ts @@ -0,0 +1,42 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Template } from './V1Template'; +import { V1TemplateInstanceRequester } from './V1TemplateInstanceRequester'; +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * TemplateInstanceSpec describes the desired state of a TemplateInstance. + * @export + * @interface V1TemplateInstanceSpec + */ +export interface V1TemplateInstanceSpec { + /** + * + * @type {V1TemplateInstanceRequester} + * @memberof V1TemplateInstanceSpec + */ + requester: V1TemplateInstanceRequester; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1TemplateInstanceSpec + */ + secret?: V1LocalObjectReference; + /** + * + * @type {V1Template} + * @memberof V1TemplateInstanceSpec + */ + template: V1Template; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TemplateInstanceStatus.ts b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceStatus.ts new file mode 100644 index 00000000000..367c22fd29d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TemplateInstanceStatus.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1TemplateInstanceCondition } from './V1TemplateInstanceCondition'; +import { V1TemplateInstanceObject } from './V1TemplateInstanceObject'; + +/** + * TemplateInstanceStatus describes the current state of a TemplateInstance. + * @export + * @interface V1TemplateInstanceStatus + */ +export interface V1TemplateInstanceStatus { + /** + * conditions represent the latest available observations of a TemplateInstance\'s current state. + * @type {Array} + * @memberof V1TemplateInstanceStatus + */ + conditions?: V1TemplateInstanceCondition[]; + /** + * Objects references the objects created by the TemplateInstance. + * @type {Array} + * @memberof V1TemplateInstanceStatus + */ + objects?: V1TemplateInstanceObject[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TemplateList.ts b/frontend/packages/kube-types/src/openshift/V1TemplateList.ts new file mode 100644 index 00000000000..1de7004e261 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TemplateList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Template } from './V1Template'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * TemplateList is a list of Template objects. + * @export + * @interface V1TemplateList + */ +export interface V1TemplateList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1TemplateList + */ + apiVersion?: string; + /** + * Items is a list of templates + * @type {Array} + * @memberof V1TemplateList + */ + items: V1Template[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1TemplateList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1TemplateList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TokenReview.ts b/frontend/packages/kube-types/src/openshift/V1TokenReview.ts new file mode 100644 index 00000000000..e63f5c68cf3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TokenReview.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1TokenReviewSpec } from './V1TokenReviewSpec'; +import { V1TokenReviewStatus } from './V1TokenReviewStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * TokenReview attempts to authenticate a token to a known user. Note: TokenReview requests may be cached by the webhook token authenticator plugin in the kube-apiserver. + * @export + * @interface V1TokenReview + */ +export interface V1TokenReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1TokenReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1TokenReview + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1TokenReview + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1TokenReviewSpec} + * @memberof V1TokenReview + */ + spec: V1TokenReviewSpec; + /** + * + * @type {V1TokenReviewStatus} + * @memberof V1TokenReview + */ + status?: V1TokenReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TokenReviewSpec.ts b/frontend/packages/kube-types/src/openshift/V1TokenReviewSpec.ts new file mode 100644 index 00000000000..908b4ffa68b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TokenReviewSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TokenReviewSpec is a description of the token authentication request. + * @export + * @interface V1TokenReviewSpec + */ +export interface V1TokenReviewSpec { + /** + * Token is the opaque bearer token. + * @type {string} + * @memberof V1TokenReviewSpec + */ + token?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TokenReviewStatus.ts b/frontend/packages/kube-types/src/openshift/V1TokenReviewStatus.ts new file mode 100644 index 00000000000..d6b102ea35c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TokenReviewStatus.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1UserInfo } from './V1UserInfo'; + +/** + * TokenReviewStatus is the result of the token authentication request. + * @export + * @interface V1TokenReviewStatus + */ +export interface V1TokenReviewStatus { + /** + * Authenticated indicates that the token was associated with a known user. + * @type {boolean} + * @memberof V1TokenReviewStatus + */ + authenticated?: boolean; + /** + * Error indicates that the token couldn\'t be checked + * @type {string} + * @memberof V1TokenReviewStatus + */ + error?: string; + /** + * + * @type {V1UserInfo} + * @memberof V1TokenReviewStatus + */ + user?: V1UserInfo; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Toleration.ts b/frontend/packages/kube-types/src/openshift/V1Toleration.ts new file mode 100644 index 00000000000..74f97cbfa4d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Toleration.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator . + * @export + * @interface V1Toleration + */ +export interface V1Toleration { + /** + * Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. + * @type {string} + * @memberof V1Toleration + */ + effect?: string; + /** + * Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. + * @type {string} + * @memberof V1Toleration + */ + key?: string; + /** + * Operator represents a key\'s relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. + * @type {string} + * @memberof V1Toleration + */ + operator?: string; + /** + * TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. + * @type {number} + * @memberof V1Toleration + */ + tolerationSeconds?: number; + /** + * Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. + * @type {string} + * @memberof V1Toleration + */ + value?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TopologySelectorLabelRequirement.ts b/frontend/packages/kube-types/src/openshift/V1TopologySelectorLabelRequirement.ts new file mode 100644 index 00000000000..c15e9a986a4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TopologySelectorLabelRequirement.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * A topology selector requirement is a selector that matches given label. This is an alpha feature and may change in the future. + * @export + * @interface V1TopologySelectorLabelRequirement + */ +export interface V1TopologySelectorLabelRequirement { + /** + * The label key that the selector applies to. + * @type {string} + * @memberof V1TopologySelectorLabelRequirement + */ + key: string; + /** + * An array of string values. One value must match the label to be selected. Each entry in Values is ORed. + * @type {Array} + * @memberof V1TopologySelectorLabelRequirement + */ + values: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1TopologySelectorTerm.ts b/frontend/packages/kube-types/src/openshift/V1TopologySelectorTerm.ts new file mode 100644 index 00000000000..687b632fb16 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1TopologySelectorTerm.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1TopologySelectorLabelRequirement } from './V1TopologySelectorLabelRequirement'; + +/** + * A topology selector term represents the result of label queries. A null or empty topology selector term matches no objects. The requirements of them are ANDed. It provides a subset of functionality as NodeSelectorTerm. This is an alpha feature and may change in the future. + * @export + * @interface V1TopologySelectorTerm + */ +export interface V1TopologySelectorTerm { + /** + * A list of topology selector requirements by labels. + * @type {Array} + * @memberof V1TopologySelectorTerm + */ + matchLabelExpressions?: V1TopologySelectorLabelRequirement[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1UserInfo.ts b/frontend/packages/kube-types/src/openshift/V1UserInfo.ts new file mode 100644 index 00000000000..77ca537fc6f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1UserInfo.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * UserInfo holds the information about the user needed to implement the user.Info interface. + * @export + * @interface V1UserInfo + */ +export interface V1UserInfo { + /** + * Any additional information provided by the authenticator. + * @type {{ [key: string]: Array; }} + * @memberof V1UserInfo + */ + extra?: { [key: string]: string[] }; + /** + * The names of groups this user is a part of. + * @type {Array} + * @memberof V1UserInfo + */ + groups?: string[]; + /** + * A unique value that identifies this user across time. If this user is deleted and another user by the same name is added, they will have different UIDs. + * @type {string} + * @memberof V1UserInfo + */ + uid?: string; + /** + * The name that uniquely identifies this user among all active users. + * @type {string} + * @memberof V1UserInfo + */ + username?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1Volume.ts b/frontend/packages/kube-types/src/openshift/V1Volume.ts new file mode 100644 index 00000000000..d9bce2d9c9c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1Volume.ts @@ -0,0 +1,216 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1AWSElasticBlockStoreVolumeSource } from './V1AWSElasticBlockStoreVolumeSource'; +import { V1AzureDiskVolumeSource } from './V1AzureDiskVolumeSource'; +import { V1AzureFileVolumeSource } from './V1AzureFileVolumeSource'; +import { V1CephFSVolumeSource } from './V1CephFSVolumeSource'; +import { V1CinderVolumeSource } from './V1CinderVolumeSource'; +import { V1ConfigMapVolumeSource } from './V1ConfigMapVolumeSource'; +import { V1DownwardAPIVolumeSource } from './V1DownwardAPIVolumeSource'; +import { V1EmptyDirVolumeSource } from './V1EmptyDirVolumeSource'; +import { V1FCVolumeSource } from './V1FCVolumeSource'; +import { V1FlexVolumeSource } from './V1FlexVolumeSource'; +import { V1FlockerVolumeSource } from './V1FlockerVolumeSource'; +import { V1GCEPersistentDiskVolumeSource } from './V1GCEPersistentDiskVolumeSource'; +import { V1GitRepoVolumeSource } from './V1GitRepoVolumeSource'; +import { V1GlusterfsVolumeSource } from './V1GlusterfsVolumeSource'; +import { V1HostPathVolumeSource } from './V1HostPathVolumeSource'; +import { V1ISCSIVolumeSource } from './V1ISCSIVolumeSource'; +import { V1NFSVolumeSource } from './V1NFSVolumeSource'; +import { V1PersistentVolumeClaimVolumeSource } from './V1PersistentVolumeClaimVolumeSource'; +import { V1PhotonPersistentDiskVolumeSource } from './V1PhotonPersistentDiskVolumeSource'; +import { V1PortworxVolumeSource } from './V1PortworxVolumeSource'; +import { V1ProjectedVolumeSource } from './V1ProjectedVolumeSource'; +import { V1QuobyteVolumeSource } from './V1QuobyteVolumeSource'; +import { V1RBDVolumeSource } from './V1RBDVolumeSource'; +import { V1ScaleIOVolumeSource } from './V1ScaleIOVolumeSource'; +import { V1SecretVolumeSource } from './V1SecretVolumeSource'; +import { V1StorageOSVolumeSource } from './V1StorageOSVolumeSource'; +import { V1VsphereVirtualDiskVolumeSource } from './V1VsphereVirtualDiskVolumeSource'; + +/** + * Volume represents a named volume in a pod that may be accessed by any container in the pod. + * @export + * @interface V1Volume + */ +export interface V1Volume { + /** + * + * @type {V1AWSElasticBlockStoreVolumeSource} + * @memberof V1Volume + */ + awsElasticBlockStore?: V1AWSElasticBlockStoreVolumeSource; + /** + * + * @type {V1AzureDiskVolumeSource} + * @memberof V1Volume + */ + azureDisk?: V1AzureDiskVolumeSource; + /** + * + * @type {V1AzureFileVolumeSource} + * @memberof V1Volume + */ + azureFile?: V1AzureFileVolumeSource; + /** + * + * @type {V1CephFSVolumeSource} + * @memberof V1Volume + */ + cephfs?: V1CephFSVolumeSource; + /** + * + * @type {V1CinderVolumeSource} + * @memberof V1Volume + */ + cinder?: V1CinderVolumeSource; + /** + * + * @type {V1ConfigMapVolumeSource} + * @memberof V1Volume + */ + configMap?: V1ConfigMapVolumeSource; + /** + * + * @type {V1DownwardAPIVolumeSource} + * @memberof V1Volume + */ + downwardAPI?: V1DownwardAPIVolumeSource; + /** + * + * @type {V1EmptyDirVolumeSource} + * @memberof V1Volume + */ + emptyDir?: V1EmptyDirVolumeSource; + /** + * + * @type {V1FCVolumeSource} + * @memberof V1Volume + */ + fc?: V1FCVolumeSource; + /** + * + * @type {V1FlexVolumeSource} + * @memberof V1Volume + */ + flexVolume?: V1FlexVolumeSource; + /** + * + * @type {V1FlockerVolumeSource} + * @memberof V1Volume + */ + flocker?: V1FlockerVolumeSource; + /** + * + * @type {V1GCEPersistentDiskVolumeSource} + * @memberof V1Volume + */ + gcePersistentDisk?: V1GCEPersistentDiskVolumeSource; + /** + * + * @type {V1GitRepoVolumeSource} + * @memberof V1Volume + */ + gitRepo?: V1GitRepoVolumeSource; + /** + * + * @type {V1GlusterfsVolumeSource} + * @memberof V1Volume + */ + glusterfs?: V1GlusterfsVolumeSource; + /** + * + * @type {V1HostPathVolumeSource} + * @memberof V1Volume + */ + hostPath?: V1HostPathVolumeSource; + /** + * + * @type {V1ISCSIVolumeSource} + * @memberof V1Volume + */ + iscsi?: V1ISCSIVolumeSource; + /** + * Volume\'s name. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1Volume + */ + name: string; + /** + * + * @type {V1NFSVolumeSource} + * @memberof V1Volume + */ + nfs?: V1NFSVolumeSource; + /** + * + * @type {V1PersistentVolumeClaimVolumeSource} + * @memberof V1Volume + */ + persistentVolumeClaim?: V1PersistentVolumeClaimVolumeSource; + /** + * + * @type {V1PhotonPersistentDiskVolumeSource} + * @memberof V1Volume + */ + photonPersistentDisk?: V1PhotonPersistentDiskVolumeSource; + /** + * + * @type {V1PortworxVolumeSource} + * @memberof V1Volume + */ + portworxVolume?: V1PortworxVolumeSource; + /** + * + * @type {V1ProjectedVolumeSource} + * @memberof V1Volume + */ + projected?: V1ProjectedVolumeSource; + /** + * + * @type {V1QuobyteVolumeSource} + * @memberof V1Volume + */ + quobyte?: V1QuobyteVolumeSource; + /** + * + * @type {V1RBDVolumeSource} + * @memberof V1Volume + */ + rbd?: V1RBDVolumeSource; + /** + * + * @type {V1ScaleIOVolumeSource} + * @memberof V1Volume + */ + scaleIO?: V1ScaleIOVolumeSource; + /** + * + * @type {V1SecretVolumeSource} + * @memberof V1Volume + */ + secret?: V1SecretVolumeSource; + /** + * + * @type {V1StorageOSVolumeSource} + * @memberof V1Volume + */ + storageos?: V1StorageOSVolumeSource; + /** + * + * @type {V1VsphereVirtualDiskVolumeSource} + * @memberof V1Volume + */ + vsphereVolume?: V1VsphereVirtualDiskVolumeSource; +} diff --git a/frontend/packages/kube-types/src/openshift/V1VolumeDevice.ts b/frontend/packages/kube-types/src/openshift/V1VolumeDevice.ts new file mode 100644 index 00000000000..454f9f1338c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1VolumeDevice.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * volumeDevice describes a mapping of a raw block device within a container. + * @export + * @interface V1VolumeDevice + */ +export interface V1VolumeDevice { + /** + * devicePath is the path inside of the container that the device will be mapped to. + * @type {string} + * @memberof V1VolumeDevice + */ + devicePath: string; + /** + * name must match the name of a persistentVolumeClaim in the pod + * @type {string} + * @memberof V1VolumeDevice + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1VolumeMount.ts b/frontend/packages/kube-types/src/openshift/V1VolumeMount.ts new file mode 100644 index 00000000000..95bc212dc72 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1VolumeMount.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * VolumeMount describes a mounting of a Volume within a container. + * @export + * @interface V1VolumeMount + */ +export interface V1VolumeMount { + /** + * Path within the container at which the volume should be mounted. Must not contain \':\'. + * @type {string} + * @memberof V1VolumeMount + */ + mountPath: string; + /** + * mountPropagation determines how mounts are propagated from the host to container and the other way around. When not set, MountPropagationNone is used. This field is beta in 1.10. + * @type {string} + * @memberof V1VolumeMount + */ + mountPropagation?: string; + /** + * This must match the Name of a Volume. + * @type {string} + * @memberof V1VolumeMount + */ + name: string; + /** + * Mounted read-only if true, read-write otherwise (false or unspecified). Defaults to false. + * @type {boolean} + * @memberof V1VolumeMount + */ + readOnly?: boolean; + /** + * Path within the volume from which the container\'s volume should be mounted. Defaults to \"\" (volume\'s root). + * @type {string} + * @memberof V1VolumeMount + */ + subPath?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1VolumeNodeAffinity.ts b/frontend/packages/kube-types/src/openshift/V1VolumeNodeAffinity.ts new file mode 100644 index 00000000000..887d1696328 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1VolumeNodeAffinity.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeSelector } from './V1NodeSelector'; + +/** + * VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from. + * @export + * @interface V1VolumeNodeAffinity + */ +export interface V1VolumeNodeAffinity { + /** + * + * @type {V1NodeSelector} + * @memberof V1VolumeNodeAffinity + */ + required?: V1NodeSelector; +} diff --git a/frontend/packages/kube-types/src/openshift/V1VolumeProjection.ts b/frontend/packages/kube-types/src/openshift/V1VolumeProjection.ts new file mode 100644 index 00000000000..1c9ba02466d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1VolumeProjection.ts @@ -0,0 +1,49 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ConfigMapProjection } from './V1ConfigMapProjection'; +import { V1DownwardAPIProjection } from './V1DownwardAPIProjection'; +import { V1SecretProjection } from './V1SecretProjection'; +import { V1ServiceAccountTokenProjection } from './V1ServiceAccountTokenProjection'; + +/** + * Projection that may be projected along with other supported volume types + * @export + * @interface V1VolumeProjection + */ +export interface V1VolumeProjection { + /** + * + * @type {V1ConfigMapProjection} + * @memberof V1VolumeProjection + */ + configMap?: V1ConfigMapProjection; + /** + * + * @type {V1DownwardAPIProjection} + * @memberof V1VolumeProjection + */ + downwardAPI?: V1DownwardAPIProjection; + /** + * + * @type {V1SecretProjection} + * @memberof V1VolumeProjection + */ + secret?: V1SecretProjection; + /** + * + * @type {V1ServiceAccountTokenProjection} + * @memberof V1VolumeProjection + */ + serviceAccountToken?: V1ServiceAccountTokenProjection; +} diff --git a/frontend/packages/kube-types/src/openshift/V1VsphereVirtualDiskVolumeSource.ts b/frontend/packages/kube-types/src/openshift/V1VsphereVirtualDiskVolumeSource.ts new file mode 100644 index 00000000000..f5314bcaf87 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1VsphereVirtualDiskVolumeSource.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a vSphere volume resource. + * @export + * @interface V1VsphereVirtualDiskVolumeSource + */ +export interface V1VsphereVirtualDiskVolumeSource { + /** + * Filesystem type to mount. Must be a filesystem type supported by the host operating system. Ex. \"ext4\", \"xfs\", \"ntfs\". Implicitly inferred to be \"ext4\" if unspecified. + * @type {string} + * @memberof V1VsphereVirtualDiskVolumeSource + */ + fsType?: string; + /** + * Storage Policy Based Management (SPBM) profile ID associated with the StoragePolicyName. + * @type {string} + * @memberof V1VsphereVirtualDiskVolumeSource + */ + storagePolicyID?: string; + /** + * Storage Policy Based Management (SPBM) profile name. + * @type {string} + * @memberof V1VsphereVirtualDiskVolumeSource + */ + storagePolicyName?: string; + /** + * Path that identifies vSphere volume vmdk + * @type {string} + * @memberof V1VsphereVirtualDiskVolumeSource + */ + volumePath: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1WatchEvent.ts b/frontend/packages/kube-types/src/openshift/V1WatchEvent.ts new file mode 100644 index 00000000000..fb39075f497 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1WatchEvent.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { IoK8sApimachineryPkgRuntimeRawExtension } from './IoK8sApimachineryPkgRuntimeRawExtension'; + +/** + * Event represents a single event to a watched resource. + * @export + * @interface V1WatchEvent + */ +export interface V1WatchEvent { + /** + * + * @type {IoK8sApimachineryPkgRuntimeRawExtension} + * @memberof V1WatchEvent + */ + object: IoK8sApimachineryPkgRuntimeRawExtension; + /** + * + * @type {string} + * @memberof V1WatchEvent + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1WeightedPodAffinityTerm.ts b/frontend/packages/kube-types/src/openshift/V1WeightedPodAffinityTerm.ts new file mode 100644 index 00000000000..d169aa87d3c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1WeightedPodAffinityTerm.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodAffinityTerm } from './V1PodAffinityTerm'; + +/** + * The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) + * @export + * @interface V1WeightedPodAffinityTerm + */ +export interface V1WeightedPodAffinityTerm { + /** + * + * @type {V1PodAffinityTerm} + * @memberof V1WeightedPodAffinityTerm + */ + podAffinityTerm: V1PodAffinityTerm; + /** + * weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + * @type {number} + * @memberof V1WeightedPodAffinityTerm + */ + weight: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1AggregationRule.ts b/frontend/packages/kube-types/src/openshift/V1beta1AggregationRule.ts new file mode 100644 index 00000000000..e377d9f8b81 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1AggregationRule.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole + * @export + * @interface V1beta1AggregationRule + */ +export interface V1beta1AggregationRule { + /** + * ClusterRoleSelectors holds a list of selectors which will be used to find ClusterRoles and create the rules. If any of the selectors match, then the ClusterRole\'s permissions will be added + * @type {Array} + * @memberof V1beta1AggregationRule + */ + clusterRoleSelectors?: V1LabelSelector[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1AllowedFlexVolume.ts b/frontend/packages/kube-types/src/openshift/V1beta1AllowedFlexVolume.ts new file mode 100644 index 00000000000..898b424f33c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1AllowedFlexVolume.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * AllowedFlexVolume represents a single Flexvolume that is allowed to be used. + * @export + * @interface V1beta1AllowedFlexVolume + */ +export interface V1beta1AllowedFlexVolume { + /** + * driver is the name of the Flexvolume driver. + * @type {string} + * @memberof V1beta1AllowedFlexVolume + */ + driver: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1AllowedHostPath.ts b/frontend/packages/kube-types/src/openshift/V1beta1AllowedHostPath.ts new file mode 100644 index 00000000000..1484483a0f8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1AllowedHostPath.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * AllowedHostPath defines the host volume conditions that will be enabled by a policy for pods to use. It requires the path prefix to be defined. + * @export + * @interface V1beta1AllowedHostPath + */ +export interface V1beta1AllowedHostPath { + /** + * pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path. Examples: `/foo` would allow `/foo`, `/foo/` and `/foo/bar` `/foo` would not allow `/food` or `/etc/foo` + * @type {string} + * @memberof V1beta1AllowedHostPath + */ + pathPrefix?: string; + /** + * when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly. + * @type {boolean} + * @memberof V1beta1AllowedHostPath + */ + readOnly?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequest.ts b/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequest.ts new file mode 100644 index 00000000000..f432f5873de --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequest.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1CertificateSigningRequestSpec } from './V1beta1CertificateSigningRequestSpec'; +import { V1beta1CertificateSigningRequestStatus } from './V1beta1CertificateSigningRequestStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Describes a certificate signing request + * @export + * @interface V1beta1CertificateSigningRequest + */ +export interface V1beta1CertificateSigningRequest { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1CertificateSigningRequest + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1CertificateSigningRequest + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1CertificateSigningRequest + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1CertificateSigningRequestSpec} + * @memberof V1beta1CertificateSigningRequest + */ + spec?: V1beta1CertificateSigningRequestSpec; + /** + * + * @type {V1beta1CertificateSigningRequestStatus} + * @memberof V1beta1CertificateSigningRequest + */ + status?: V1beta1CertificateSigningRequestStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestCondition.ts b/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestCondition.ts new file mode 100644 index 00000000000..d3e972ab454 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestCondition.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1beta1CertificateSigningRequestCondition + */ +export interface V1beta1CertificateSigningRequestCondition { + /** + * + * @type {string} + * @memberof V1beta1CertificateSigningRequestCondition + */ + lastUpdateTime?: string; + /** + * human readable message with details about the request state + * @type {string} + * @memberof V1beta1CertificateSigningRequestCondition + */ + message?: string; + /** + * brief reason for the request state + * @type {string} + * @memberof V1beta1CertificateSigningRequestCondition + */ + reason?: string; + /** + * request approval state, currently Approved or Denied. + * @type {string} + * @memberof V1beta1CertificateSigningRequestCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestList.ts b/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestList.ts new file mode 100644 index 00000000000..d8491132e0d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1CertificateSigningRequest } from './V1beta1CertificateSigningRequest'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * + * @export + * @interface V1beta1CertificateSigningRequestList + */ +export interface V1beta1CertificateSigningRequestList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1CertificateSigningRequestList + */ + apiVersion?: string; + /** + * + * @type {Array} + * @memberof V1beta1CertificateSigningRequestList + */ + items: V1beta1CertificateSigningRequest[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1CertificateSigningRequestList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1CertificateSigningRequestList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestSpec.ts new file mode 100644 index 00000000000..f25c43dbba9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestSpec.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * This information is immutable after the request is created. Only the Request and Usages fields can be set on creation, other fields are derived by Kubernetes and cannot be modified by users. + * @export + * @interface V1beta1CertificateSigningRequestSpec + */ +export interface V1beta1CertificateSigningRequestSpec { + /** + * Extra information about the requesting user. See user.Info interface for details. + * @type {{ [key: string]: Array; }} + * @memberof V1beta1CertificateSigningRequestSpec + */ + extra?: { [key: string]: string[] }; + /** + * Group information about the requesting user. See user.Info interface for details. + * @type {Array} + * @memberof V1beta1CertificateSigningRequestSpec + */ + groups?: string[]; + /** + * Base64-encoded PKCS#10 CSR data + * @type {string} + * @memberof V1beta1CertificateSigningRequestSpec + */ + request: string; + /** + * UID information about the requesting user. See user.Info interface for details. + * @type {string} + * @memberof V1beta1CertificateSigningRequestSpec + */ + uid?: string; + /** + * allowedUsages specifies a set of usage contexts the key will be valid for. See: https://tools.ietf.org/html/rfc5280#section-4.2.1.3 https://tools.ietf.org/html/rfc5280#section-4.2.1.12 + * @type {Array} + * @memberof V1beta1CertificateSigningRequestSpec + */ + usages?: string[]; + /** + * Information about the requesting user. See user.Info interface for details. + * @type {string} + * @memberof V1beta1CertificateSigningRequestSpec + */ + username?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestStatus.ts new file mode 100644 index 00000000000..1da9f8e41dc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1CertificateSigningRequestStatus.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1CertificateSigningRequestCondition } from './V1beta1CertificateSigningRequestCondition'; + +/** + * + * @export + * @interface V1beta1CertificateSigningRequestStatus + */ +export interface V1beta1CertificateSigningRequestStatus { + /** + * If request was approved, the controller will place the issued certificate here. + * @type {string} + * @memberof V1beta1CertificateSigningRequestStatus + */ + certificate?: string; + /** + * Conditions applied to the request, such as approval or denial. + * @type {Array} + * @memberof V1beta1CertificateSigningRequestStatus + */ + conditions?: V1beta1CertificateSigningRequestCondition[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ClusterRole.ts b/frontend/packages/kube-types/src/openshift/V1beta1ClusterRole.ts new file mode 100644 index 00000000000..ab44ebbf9c9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ClusterRole.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1AggregationRule } from './V1beta1AggregationRule'; +import { V1beta1PolicyRule } from './V1beta1PolicyRule'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding. + * @export + * @interface V1beta1ClusterRole + */ +export interface V1beta1ClusterRole { + /** + * + * @type {V1beta1AggregationRule} + * @memberof V1beta1ClusterRole + */ + aggregationRule?: V1beta1AggregationRule; + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1ClusterRole + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1ClusterRole + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1ClusterRole + */ + metadata?: V1ObjectMeta; + /** + * Rules holds all the PolicyRules for this ClusterRole + * @type {Array} + * @memberof V1beta1ClusterRole + */ + rules: V1beta1PolicyRule[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleBinding.ts b/frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleBinding.ts new file mode 100644 index 00000000000..593426040da --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleBinding.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1RoleRef } from './V1beta1RoleRef'; +import { V1beta1Subject } from './V1beta1Subject'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject. + * @export + * @interface V1beta1ClusterRoleBinding + */ +export interface V1beta1ClusterRoleBinding { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1ClusterRoleBinding + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1ClusterRoleBinding + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1ClusterRoleBinding + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1RoleRef} + * @memberof V1beta1ClusterRoleBinding + */ + roleRef: V1beta1RoleRef; + /** + * Subjects holds references to the objects the role applies to. + * @type {Array} + * @memberof V1beta1ClusterRoleBinding + */ + subjects?: V1beta1Subject[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleBindingList.ts b/frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleBindingList.ts new file mode 100644 index 00000000000..38aea24108b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleBindingList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1ClusterRoleBinding } from './V1beta1ClusterRoleBinding'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ClusterRoleBindingList is a collection of ClusterRoleBindings + * @export + * @interface V1beta1ClusterRoleBindingList + */ +export interface V1beta1ClusterRoleBindingList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1ClusterRoleBindingList + */ + apiVersion?: string; + /** + * Items is a list of ClusterRoleBindings + * @type {Array} + * @memberof V1beta1ClusterRoleBindingList + */ + items: V1beta1ClusterRoleBinding[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1ClusterRoleBindingList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1ClusterRoleBindingList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleList.ts b/frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleList.ts new file mode 100644 index 00000000000..7e2c8c31bf6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ClusterRoleList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1ClusterRole } from './V1beta1ClusterRole'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ClusterRoleList is a collection of ClusterRoles + * @export + * @interface V1beta1ClusterRoleList + */ +export interface V1beta1ClusterRoleList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1ClusterRoleList + */ + apiVersion?: string; + /** + * Items is a list of ClusterRoles + * @type {Array} + * @memberof V1beta1ClusterRoleList + */ + items: V1beta1ClusterRole[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1ClusterRoleList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1ClusterRoleList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ControllerRevision.ts b/frontend/packages/kube-types/src/openshift/V1beta1ControllerRevision.ts new file mode 100644 index 00000000000..6dbd5578695 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ControllerRevision.ts @@ -0,0 +1,53 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { IoK8sApimachineryPkgRuntimeRawExtension } from './IoK8sApimachineryPkgRuntimeRawExtension'; + +/** + * DEPRECATED - This group version of ControllerRevision is deprecated by apps/v1beta2/ControllerRevision. See the release notes for more information. ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. + * @export + * @interface V1beta1ControllerRevision + */ +export interface V1beta1ControllerRevision { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1ControllerRevision + */ + apiVersion?: string; + /** + * + * @type {IoK8sApimachineryPkgRuntimeRawExtension} + * @memberof V1beta1ControllerRevision + */ + data?: IoK8sApimachineryPkgRuntimeRawExtension; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1ControllerRevision + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1ControllerRevision + */ + metadata?: V1ObjectMeta; + /** + * Revision indicates the revision of the state represented by Data. + * @type {number} + * @memberof V1beta1ControllerRevision + */ + revision: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ControllerRevisionList.ts b/frontend/packages/kube-types/src/openshift/V1beta1ControllerRevisionList.ts new file mode 100644 index 00000000000..25105291d49 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ControllerRevisionList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1ControllerRevision } from './V1beta1ControllerRevision'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ControllerRevisionList is a resource containing a list of ControllerRevision objects. + * @export + * @interface V1beta1ControllerRevisionList + */ +export interface V1beta1ControllerRevisionList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1ControllerRevisionList + */ + apiVersion?: string; + /** + * Items is the list of ControllerRevisions + * @type {Array} + * @memberof V1beta1ControllerRevisionList + */ + items: V1beta1ControllerRevision[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1ControllerRevisionList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1ControllerRevisionList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1CronJob.ts b/frontend/packages/kube-types/src/openshift/V1beta1CronJob.ts new file mode 100644 index 00000000000..db826ac294e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1CronJob.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1CronJobSpec } from './V1beta1CronJobSpec'; +import { V1beta1CronJobStatus } from './V1beta1CronJobStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * CronJob represents the configuration of a single cron job. + * @export + * @interface V1beta1CronJob + */ +export interface V1beta1CronJob { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1CronJob + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1CronJob + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1CronJob + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1CronJobSpec} + * @memberof V1beta1CronJob + */ + spec?: V1beta1CronJobSpec; + /** + * + * @type {V1beta1CronJobStatus} + * @memberof V1beta1CronJob + */ + status?: V1beta1CronJobStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1CronJobList.ts b/frontend/packages/kube-types/src/openshift/V1beta1CronJobList.ts new file mode 100644 index 00000000000..b39fff0cceb --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1CronJobList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1CronJob } from './V1beta1CronJob'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * CronJobList is a collection of cron jobs. + * @export + * @interface V1beta1CronJobList + */ +export interface V1beta1CronJobList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1CronJobList + */ + apiVersion?: string; + /** + * items is the list of CronJobs. + * @type {Array} + * @memberof V1beta1CronJobList + */ + items: V1beta1CronJob[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1CronJobList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1CronJobList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1CronJobSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1CronJobSpec.ts new file mode 100644 index 00000000000..deccae4ce53 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1CronJobSpec.ts @@ -0,0 +1,64 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1JobTemplateSpec } from './V1beta1JobTemplateSpec'; + +/** + * CronJobSpec describes how the job execution will look like and when it will actually run. + * @export + * @interface V1beta1CronJobSpec + */ +export interface V1beta1CronJobSpec { + /** + * Specifies how to treat concurrent executions of a Job. Valid values are: - \"Allow\" (default): allows CronJobs to run concurrently; - \"Forbid\": forbids concurrent runs, skipping next run if previous run hasn\'t finished yet; - \"Replace\": cancels currently running job and replaces it with a new one + * @type {string} + * @memberof V1beta1CronJobSpec + */ + concurrencyPolicy?: string; + /** + * The number of failed finished jobs to retain. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. + * @type {number} + * @memberof V1beta1CronJobSpec + */ + failedJobsHistoryLimit?: number; + /** + * + * @type {V1beta1JobTemplateSpec} + * @memberof V1beta1CronJobSpec + */ + jobTemplate: V1beta1JobTemplateSpec; + /** + * The schedule in Cron format, see https://en.wikipedia.org/wiki/Cron. + * @type {string} + * @memberof V1beta1CronJobSpec + */ + schedule: string; + /** + * Optional deadline in seconds for starting the job if it misses scheduled time for any reason. Missed jobs executions will be counted as failed ones. + * @type {number} + * @memberof V1beta1CronJobSpec + */ + startingDeadlineSeconds?: number; + /** + * The number of successful finished jobs to retain. This is a pointer to distinguish between explicit zero and not specified. Defaults to 3. + * @type {number} + * @memberof V1beta1CronJobSpec + */ + successfulJobsHistoryLimit?: number; + /** + * This flag tells the controller to suspend subsequent executions, it does not apply to already started executions. Defaults to false. + * @type {boolean} + * @memberof V1beta1CronJobSpec + */ + suspend?: boolean; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1CronJobStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta1CronJobStatus.ts new file mode 100644 index 00000000000..c8665fc114b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1CronJobStatus.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectReference } from './V1ObjectReference'; + +/** + * CronJobStatus represents the current state of a cron job. + * @export + * @interface V1beta1CronJobStatus + */ +export interface V1beta1CronJobStatus { + /** + * A list of pointers to currently running jobs. + * @type {Array} + * @memberof V1beta1CronJobStatus + */ + active?: V1ObjectReference[]; + /** + * + * @type {string} + * @memberof V1beta1CronJobStatus + */ + lastScheduleTime?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1Deployment.ts b/frontend/packages/kube-types/src/openshift/V1beta1Deployment.ts new file mode 100644 index 00000000000..7fb6a924221 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1Deployment.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1DeploymentSpec } from './V1beta1DeploymentSpec'; +import { V1beta1DeploymentStatus } from './V1beta1DeploymentStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * DEPRECATED - This group version of Deployment is deprecated by apps/v1beta2/Deployment. See the release notes for more information. Deployment enables declarative updates for Pods and ReplicaSets. + * @export + * @interface V1beta1Deployment + */ +export interface V1beta1Deployment { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1Deployment + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1Deployment + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1Deployment + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1DeploymentSpec} + * @memberof V1beta1Deployment + */ + spec?: V1beta1DeploymentSpec; + /** + * + * @type {V1beta1DeploymentStatus} + * @memberof V1beta1Deployment + */ + status?: V1beta1DeploymentStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1DeploymentCondition.ts b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentCondition.ts new file mode 100644 index 00000000000..cdb81253520 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentCondition.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DeploymentCondition describes the state of a deployment at a certain point. + * @export + * @interface V1beta1DeploymentCondition + */ +export interface V1beta1DeploymentCondition { + /** + * + * @type {string} + * @memberof V1beta1DeploymentCondition + */ + lastTransitionTime?: string; + /** + * + * @type {string} + * @memberof V1beta1DeploymentCondition + */ + lastUpdateTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof V1beta1DeploymentCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof V1beta1DeploymentCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1beta1DeploymentCondition + */ + status: string; + /** + * Type of deployment condition. + * @type {string} + * @memberof V1beta1DeploymentCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1DeploymentList.ts b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentList.ts new file mode 100644 index 00000000000..b74b28adfb6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1Deployment } from './V1beta1Deployment'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * DeploymentList is a list of Deployments. + * @export + * @interface V1beta1DeploymentList + */ +export interface V1beta1DeploymentList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1DeploymentList + */ + apiVersion?: string; + /** + * Items is the list of Deployments. + * @type {Array} + * @memberof V1beta1DeploymentList + */ + items: V1beta1Deployment[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1DeploymentList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1DeploymentList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1DeploymentRollback.ts b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentRollback.ts new file mode 100644 index 00000000000..6016f78c3f1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentRollback.ts @@ -0,0 +1,52 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1RollbackConfig } from './V1beta1RollbackConfig'; + +/** + * DEPRECATED. DeploymentRollback stores the information required to rollback a deployment. + * @export + * @interface V1beta1DeploymentRollback + */ +export interface V1beta1DeploymentRollback { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1DeploymentRollback + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1DeploymentRollback + */ + kind?: string; + /** + * Required: This must match the Name of a deployment. + * @type {string} + * @memberof V1beta1DeploymentRollback + */ + name: string; + /** + * + * @type {V1beta1RollbackConfig} + * @memberof V1beta1DeploymentRollback + */ + rollbackTo: V1beta1RollbackConfig; + /** + * The annotations to be updated to a deployment + * @type {{ [key: string]: string; }} + * @memberof V1beta1DeploymentRollback + */ + updatedAnnotations?: { [key: string]: string }; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1DeploymentSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentSpec.ts new file mode 100644 index 00000000000..e1830562a1c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentSpec.ts @@ -0,0 +1,79 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1DeploymentStrategy } from './V1beta1DeploymentStrategy'; +import { V1beta1RollbackConfig } from './V1beta1RollbackConfig'; +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * DeploymentSpec is the specification of the desired behavior of the Deployment. + * @export + * @interface V1beta1DeploymentSpec + */ +export interface V1beta1DeploymentSpec { + /** + * Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) + * @type {number} + * @memberof V1beta1DeploymentSpec + */ + minReadySeconds?: number; + /** + * Indicates that the deployment is paused. + * @type {boolean} + * @memberof V1beta1DeploymentSpec + */ + paused?: boolean; + /** + * The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s. + * @type {number} + * @memberof V1beta1DeploymentSpec + */ + progressDeadlineSeconds?: number; + /** + * Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. + * @type {number} + * @memberof V1beta1DeploymentSpec + */ + replicas?: number; + /** + * The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 2. + * @type {number} + * @memberof V1beta1DeploymentSpec + */ + revisionHistoryLimit?: number; + /** + * + * @type {V1beta1RollbackConfig} + * @memberof V1beta1DeploymentSpec + */ + rollbackTo?: V1beta1RollbackConfig; + /** + * + * @type {V1LabelSelector} + * @memberof V1beta1DeploymentSpec + */ + selector?: V1LabelSelector; + /** + * + * @type {V1beta1DeploymentStrategy} + * @memberof V1beta1DeploymentSpec + */ + strategy?: V1beta1DeploymentStrategy; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1beta1DeploymentSpec + */ + template: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1DeploymentStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentStatus.ts new file mode 100644 index 00000000000..1ebc3d50577 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentStatus.ts @@ -0,0 +1,70 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1DeploymentCondition } from './V1beta1DeploymentCondition'; + +/** + * DeploymentStatus is the most recently observed status of the Deployment. + * @export + * @interface V1beta1DeploymentStatus + */ +export interface V1beta1DeploymentStatus { + /** + * Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. + * @type {number} + * @memberof V1beta1DeploymentStatus + */ + availableReplicas?: number; + /** + * Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet. + * @type {number} + * @memberof V1beta1DeploymentStatus + */ + collisionCount?: number; + /** + * Represents the latest available observations of a deployment\'s current state. + * @type {Array} + * @memberof V1beta1DeploymentStatus + */ + conditions?: V1beta1DeploymentCondition[]; + /** + * The generation observed by the deployment controller. + * @type {number} + * @memberof V1beta1DeploymentStatus + */ + observedGeneration?: number; + /** + * Total number of ready pods targeted by this deployment. + * @type {number} + * @memberof V1beta1DeploymentStatus + */ + readyReplicas?: number; + /** + * Total number of non-terminated pods targeted by this deployment (their labels match the selector). + * @type {number} + * @memberof V1beta1DeploymentStatus + */ + replicas?: number; + /** + * Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created. + * @type {number} + * @memberof V1beta1DeploymentStatus + */ + unavailableReplicas?: number; + /** + * Total number of non-terminated pods targeted by this deployment that have the desired template spec. + * @type {number} + * @memberof V1beta1DeploymentStatus + */ + updatedReplicas?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1DeploymentStrategy.ts b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentStrategy.ts new file mode 100644 index 00000000000..6c7a2cd863c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1DeploymentStrategy.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1RollingUpdateDeployment } from './V1beta1RollingUpdateDeployment'; + +/** + * DeploymentStrategy describes how to replace existing pods with new ones. + * @export + * @interface V1beta1DeploymentStrategy + */ +export interface V1beta1DeploymentStrategy { + /** + * + * @type {V1beta1RollingUpdateDeployment} + * @memberof V1beta1DeploymentStrategy + */ + rollingUpdate?: V1beta1RollingUpdateDeployment; + /** + * Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate. + * @type {string} + * @memberof V1beta1DeploymentStrategy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1Event.ts b/frontend/packages/kube-types/src/openshift/V1beta1Event.ts new file mode 100644 index 00000000000..989e7b8f165 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1Event.ts @@ -0,0 +1,127 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1EventSource } from './V1EventSource'; +import { V1ObjectReference } from './V1ObjectReference'; +import { V1beta1EventSeries } from './V1beta1EventSeries'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. + * @export + * @interface V1beta1Event + */ +export interface V1beta1Event { + /** + * What action was taken/failed regarding to the regarding object. + * @type {string} + * @memberof V1beta1Event + */ + action?: string; + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1Event + */ + apiVersion?: string; + /** + * Deprecated field assuring backward compatibility with core.v1 Event type + * @type {number} + * @memberof V1beta1Event + */ + deprecatedCount?: number; + /** + * + * @type {string} + * @memberof V1beta1Event + */ + deprecatedFirstTimestamp?: string; + /** + * + * @type {string} + * @memberof V1beta1Event + */ + deprecatedLastTimestamp?: string; + /** + * + * @type {V1EventSource} + * @memberof V1beta1Event + */ + deprecatedSource?: V1EventSource; + /** + * + * @type {string} + * @memberof V1beta1Event + */ + eventTime: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1Event + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1Event + */ + metadata?: V1ObjectMeta; + /** + * Optional. A human-readable description of the status of this operation. Maximal length of the note is 1kB, but libraries should be prepared to handle values up to 64kB. + * @type {string} + * @memberof V1beta1Event + */ + note?: string; + /** + * Why the action was taken. + * @type {string} + * @memberof V1beta1Event + */ + reason?: string; + /** + * + * @type {V1ObjectReference} + * @memberof V1beta1Event + */ + regarding?: V1ObjectReference; + /** + * + * @type {V1ObjectReference} + * @memberof V1beta1Event + */ + related?: V1ObjectReference; + /** + * Name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`. + * @type {string} + * @memberof V1beta1Event + */ + reportingController?: string; + /** + * ID of the controller instance, e.g. `kubelet-xyzf`. + * @type {string} + * @memberof V1beta1Event + */ + reportingInstance?: string; + /** + * + * @type {V1beta1EventSeries} + * @memberof V1beta1Event + */ + series?: V1beta1EventSeries; + /** + * Type of this event (Normal, Warning), new types could be added in the future. + * @type {string} + * @memberof V1beta1Event + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1EventList.ts b/frontend/packages/kube-types/src/openshift/V1beta1EventList.ts new file mode 100644 index 00000000000..4aa0bc0288a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1EventList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1Event } from './V1beta1Event'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * EventList is a list of Event objects. + * @export + * @interface V1beta1EventList + */ +export interface V1beta1EventList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1EventList + */ + apiVersion?: string; + /** + * Items is a list of schema objects. + * @type {Array} + * @memberof V1beta1EventList + */ + items: V1beta1Event[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1EventList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1EventList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1EventSeries.ts b/frontend/packages/kube-types/src/openshift/V1beta1EventSeries.ts new file mode 100644 index 00000000000..a5f9d73425f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1EventSeries.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. + * @export + * @interface V1beta1EventSeries + */ +export interface V1beta1EventSeries { + /** + * Number of occurrences in this series up to the last heartbeat time + * @type {number} + * @memberof V1beta1EventSeries + */ + count: number; + /** + * + * @type {string} + * @memberof V1beta1EventSeries + */ + lastObservedTime: string; + /** + * Information whether this series is ongoing or finished. + * @type {string} + * @memberof V1beta1EventSeries + */ + state: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1Eviction.ts b/frontend/packages/kube-types/src/openshift/V1beta1Eviction.ts new file mode 100644 index 00000000000..5e5880a4fc0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1Eviction.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DeleteOptions } from './V1DeleteOptions'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Eviction evicts a pod from its node subject to certain policies and safety constraints. This is a subresource of Pod. A request to cause such an eviction is created by POSTing to .../pods//evictions. + * @export + * @interface V1beta1Eviction + */ +export interface V1beta1Eviction { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1Eviction + */ + apiVersion?: string; + /** + * + * @type {V1DeleteOptions} + * @memberof V1beta1Eviction + */ + deleteOptions?: V1DeleteOptions; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1Eviction + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1Eviction + */ + metadata?: V1ObjectMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1FSGroupStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/V1beta1FSGroupStrategyOptions.ts new file mode 100644 index 00000000000..69e30fdd70a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1FSGroupStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1IDRange } from './V1beta1IDRange'; + +/** + * FSGroupStrategyOptions defines the strategy type and options used to create the strategy. + * @export + * @interface V1beta1FSGroupStrategyOptions + */ +export interface V1beta1FSGroupStrategyOptions { + /** + * ranges are the allowed ranges of fs groups. If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs. + * @type {Array} + * @memberof V1beta1FSGroupStrategyOptions + */ + ranges?: V1beta1IDRange[]; + /** + * rule is the strategy that will dictate what FSGroup is used in the SecurityContext. + * @type {string} + * @memberof V1beta1FSGroupStrategyOptions + */ + rule?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1HostPortRange.ts b/frontend/packages/kube-types/src/openshift/V1beta1HostPortRange.ts new file mode 100644 index 00000000000..43615a5e4be --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1HostPortRange.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * HostPortRange defines a range of host ports that will be enabled by a policy for pods to use. It requires both the start and end to be defined. + * @export + * @interface V1beta1HostPortRange + */ +export interface V1beta1HostPortRange { + /** + * max is the end of the range, inclusive. + * @type {number} + * @memberof V1beta1HostPortRange + */ + max: number; + /** + * min is the start of the range, inclusive. + * @type {number} + * @memberof V1beta1HostPortRange + */ + min: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1IDRange.ts b/frontend/packages/kube-types/src/openshift/V1beta1IDRange.ts new file mode 100644 index 00000000000..2acf935bfb3 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1IDRange.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * IDRange provides a min/max of an allowed range of IDs. + * @export + * @interface V1beta1IDRange + */ +export interface V1beta1IDRange { + /** + * max is the end of the range, inclusive. + * @type {number} + * @memberof V1beta1IDRange + */ + max: number; + /** + * min is the start of the range, inclusive. + * @type {number} + * @memberof V1beta1IDRange + */ + min: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1JobTemplateSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1JobTemplateSpec.ts new file mode 100644 index 00000000000..978ebceaf0b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1JobTemplateSpec.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1JobSpec } from './V1JobSpec'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * JobTemplateSpec describes the data a Job should have when created from a template + * @export + * @interface V1beta1JobTemplateSpec + */ +export interface V1beta1JobTemplateSpec { + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1JobTemplateSpec + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1JobSpec} + * @memberof V1beta1JobTemplateSpec + */ + spec?: V1JobSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1LocalSubjectAccessReview.ts b/frontend/packages/kube-types/src/openshift/V1beta1LocalSubjectAccessReview.ts new file mode 100644 index 00000000000..ecf7e514341 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1LocalSubjectAccessReview.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1SubjectAccessReviewSpec } from './V1beta1SubjectAccessReviewSpec'; +import { V1beta1SubjectAccessReviewStatus } from './V1beta1SubjectAccessReviewStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * LocalSubjectAccessReview checks whether or not a user or group can perform an action in a given namespace. Having a namespace scoped resource makes it much easier to grant namespace scoped policy that includes permissions checking. + * @export + * @interface V1beta1LocalSubjectAccessReview + */ +export interface V1beta1LocalSubjectAccessReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1LocalSubjectAccessReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1LocalSubjectAccessReview + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1LocalSubjectAccessReview + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1SubjectAccessReviewSpec} + * @memberof V1beta1LocalSubjectAccessReview + */ + spec: V1beta1SubjectAccessReviewSpec; + /** + * + * @type {V1beta1SubjectAccessReviewStatus} + * @memberof V1beta1LocalSubjectAccessReview + */ + status?: V1beta1SubjectAccessReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1MutatingWebhookConfiguration.ts b/frontend/packages/kube-types/src/openshift/V1beta1MutatingWebhookConfiguration.ts new file mode 100644 index 00000000000..18e58abf30a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1MutatingWebhookConfiguration.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1Webhook } from './V1beta1Webhook'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * MutatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and may change the object. + * @export + * @interface V1beta1MutatingWebhookConfiguration + */ +export interface V1beta1MutatingWebhookConfiguration { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1MutatingWebhookConfiguration + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1MutatingWebhookConfiguration + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1MutatingWebhookConfiguration + */ + metadata?: V1ObjectMeta; + /** + * Webhooks is a list of webhooks and the affected resources and operations. + * @type {Array} + * @memberof V1beta1MutatingWebhookConfiguration + */ + webhooks?: V1beta1Webhook[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1MutatingWebhookConfigurationList.ts b/frontend/packages/kube-types/src/openshift/V1beta1MutatingWebhookConfigurationList.ts new file mode 100644 index 00000000000..0b1c485c1de --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1MutatingWebhookConfigurationList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1MutatingWebhookConfiguration } from './V1beta1MutatingWebhookConfiguration'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * MutatingWebhookConfigurationList is a list of MutatingWebhookConfiguration. + * @export + * @interface V1beta1MutatingWebhookConfigurationList + */ +export interface V1beta1MutatingWebhookConfigurationList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1MutatingWebhookConfigurationList + */ + apiVersion?: string; + /** + * List of MutatingWebhookConfiguration. + * @type {Array} + * @memberof V1beta1MutatingWebhookConfigurationList + */ + items: V1beta1MutatingWebhookConfiguration[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1MutatingWebhookConfigurationList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1MutatingWebhookConfigurationList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1NonResourceAttributes.ts b/frontend/packages/kube-types/src/openshift/V1beta1NonResourceAttributes.ts new file mode 100644 index 00000000000..073ae3879bd --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1NonResourceAttributes.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * NonResourceAttributes includes the authorization attributes available for non-resource requests to the Authorizer interface + * @export + * @interface V1beta1NonResourceAttributes + */ +export interface V1beta1NonResourceAttributes { + /** + * Path is the URL path of the request + * @type {string} + * @memberof V1beta1NonResourceAttributes + */ + path?: string; + /** + * Verb is the standard HTTP verb + * @type {string} + * @memberof V1beta1NonResourceAttributes + */ + verb?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1NonResourceRule.ts b/frontend/packages/kube-types/src/openshift/V1beta1NonResourceRule.ts new file mode 100644 index 00000000000..fce1b377dd7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1NonResourceRule.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * NonResourceRule holds information that describes a rule for the non-resource + * @export + * @interface V1beta1NonResourceRule + */ +export interface V1beta1NonResourceRule { + /** + * NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path. \"*\" means all. + * @type {Array} + * @memberof V1beta1NonResourceRule + */ + nonResourceURLs?: string[]; + /** + * Verb is a list of kubernetes non-resource API verbs, like: get, post, put, delete, patch, head, options. \"*\" means all. + * @type {Array} + * @memberof V1beta1NonResourceRule + */ + verbs: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudget.ts b/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudget.ts new file mode 100644 index 00000000000..3f7d5bb15c1 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudget.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1PodDisruptionBudgetSpec } from './V1beta1PodDisruptionBudgetSpec'; +import { V1beta1PodDisruptionBudgetStatus } from './V1beta1PodDisruptionBudgetStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * PodDisruptionBudget is an object to define the max disruption that can be caused to a collection of pods + * @export + * @interface V1beta1PodDisruptionBudget + */ +export interface V1beta1PodDisruptionBudget { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1PodDisruptionBudget + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1PodDisruptionBudget + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1PodDisruptionBudget + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1PodDisruptionBudgetSpec} + * @memberof V1beta1PodDisruptionBudget + */ + spec?: V1beta1PodDisruptionBudgetSpec; + /** + * + * @type {V1beta1PodDisruptionBudgetStatus} + * @memberof V1beta1PodDisruptionBudget + */ + status?: V1beta1PodDisruptionBudgetStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetList.ts b/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetList.ts new file mode 100644 index 00000000000..56d1655cc03 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1PodDisruptionBudget } from './V1beta1PodDisruptionBudget'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * PodDisruptionBudgetList is a collection of PodDisruptionBudgets. + * @export + * @interface V1beta1PodDisruptionBudgetList + */ +export interface V1beta1PodDisruptionBudgetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1PodDisruptionBudgetList + */ + apiVersion?: string; + /** + * + * @type {Array} + * @memberof V1beta1PodDisruptionBudgetList + */ + items: V1beta1PodDisruptionBudget[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1PodDisruptionBudgetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1PodDisruptionBudgetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetSpec.ts new file mode 100644 index 00000000000..5555dbd774f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetSpec.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * PodDisruptionBudgetSpec is a description of a PodDisruptionBudget. + * @export + * @interface V1beta1PodDisruptionBudgetSpec + */ +export interface V1beta1PodDisruptionBudgetSpec { + /** + * + * @type {string} + * @memberof V1beta1PodDisruptionBudgetSpec + */ + maxUnavailable?: string; + /** + * + * @type {string} + * @memberof V1beta1PodDisruptionBudgetSpec + */ + minAvailable?: string; + /** + * + * @type {V1LabelSelector} + * @memberof V1beta1PodDisruptionBudgetSpec + */ + selector?: V1LabelSelector; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetStatus.ts new file mode 100644 index 00000000000..028130f1d6c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1PodDisruptionBudgetStatus.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PodDisruptionBudgetStatus represents information about the status of a PodDisruptionBudget. Status may trail the actual state of a system. + * @export + * @interface V1beta1PodDisruptionBudgetStatus + */ +export interface V1beta1PodDisruptionBudgetStatus { + /** + * current number of healthy pods + * @type {number} + * @memberof V1beta1PodDisruptionBudgetStatus + */ + currentHealthy: number; + /** + * minimum desired number of healthy pods + * @type {number} + * @memberof V1beta1PodDisruptionBudgetStatus + */ + desiredHealthy: number; + /** + * DisruptedPods contains information about pods whose eviction was processed by the API server eviction subresource handler but has not yet been observed by the PodDisruptionBudget controller. A pod will be in this map from the time when the API server processed the eviction request to the time when the pod is seen by PDB controller as having been marked for deletion (or after a timeout). The key in the map is the name of the pod and the value is the time when the API server processed the eviction request. If the deletion didn\'t occur and a pod is still there it will be removed from the list automatically by PodDisruptionBudget controller after some time. If everything goes smooth this map should be empty for the most of the time. Large number of entries in the map may indicate problems with pod deletions. + * @type {{ [key: string]: string; }} + * @memberof V1beta1PodDisruptionBudgetStatus + */ + disruptedPods: { [key: string]: string }; + /** + * Number of pod disruptions that are currently allowed. + * @type {number} + * @memberof V1beta1PodDisruptionBudgetStatus + */ + disruptionsAllowed: number; + /** + * total number of pods counted by this disruption budget + * @type {number} + * @memberof V1beta1PodDisruptionBudgetStatus + */ + expectedPods: number; + /** + * Most recent generation observed when updating this PDB status. PodDisruptionsAllowed and other status informatio is valid only if observedGeneration equals to PDB\'s object generation. + * @type {number} + * @memberof V1beta1PodDisruptionBudgetStatus + */ + observedGeneration?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicy.ts b/frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicy.ts new file mode 100644 index 00000000000..25072ba28e0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicy.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1PodSecurityPolicySpec } from './V1beta1PodSecurityPolicySpec'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container. + * @export + * @interface V1beta1PodSecurityPolicy + */ +export interface V1beta1PodSecurityPolicy { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1PodSecurityPolicy + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1PodSecurityPolicy + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1PodSecurityPolicy + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1PodSecurityPolicySpec} + * @memberof V1beta1PodSecurityPolicy + */ + spec?: V1beta1PodSecurityPolicySpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicyList.ts b/frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicyList.ts new file mode 100644 index 00000000000..e493165a1cd --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicyList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1PodSecurityPolicy } from './V1beta1PodSecurityPolicy'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * PodSecurityPolicyList is a list of PodSecurityPolicy objects. + * @export + * @interface V1beta1PodSecurityPolicyList + */ +export interface V1beta1PodSecurityPolicyList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1PodSecurityPolicyList + */ + apiVersion?: string; + /** + * items is a list of schema objects. + * @type {Array} + * @memberof V1beta1PodSecurityPolicyList + */ + items: V1beta1PodSecurityPolicy[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1PodSecurityPolicyList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1PodSecurityPolicyList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicySpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicySpec.ts new file mode 100644 index 00000000000..970dcb63cb5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1PodSecurityPolicySpec.ts @@ -0,0 +1,148 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1AllowedFlexVolume } from './V1beta1AllowedFlexVolume'; +import { V1beta1AllowedHostPath } from './V1beta1AllowedHostPath'; +import { V1beta1FSGroupStrategyOptions } from './V1beta1FSGroupStrategyOptions'; +import { V1beta1HostPortRange } from './V1beta1HostPortRange'; +import { V1beta1RunAsUserStrategyOptions } from './V1beta1RunAsUserStrategyOptions'; +import { V1beta1SELinuxStrategyOptions } from './V1beta1SELinuxStrategyOptions'; +import { V1beta1SupplementalGroupsStrategyOptions } from './V1beta1SupplementalGroupsStrategyOptions'; + +/** + * PodSecurityPolicySpec defines the policy enforced. + * @export + * @interface V1beta1PodSecurityPolicySpec + */ +export interface V1beta1PodSecurityPolicySpec { + /** + * allowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true. + * @type {boolean} + * @memberof V1beta1PodSecurityPolicySpec + */ + allowPrivilegeEscalation?: boolean; + /** + * allowedCapabilities is a list of capabilities that can be requested to add to the container. Capabilities in this field may be added at the pod author\'s discretion. You must not list a capability in both allowedCapabilities and requiredDropCapabilities. + * @type {Array} + * @memberof V1beta1PodSecurityPolicySpec + */ + allowedCapabilities?: string[]; + /** + * allowedFlexVolumes is a whitelist of allowed Flexvolumes. Empty or nil indicates that all Flexvolumes may be used. This parameter is effective only when the usage of the Flexvolumes is allowed in the \"volumes\" field. + * @type {Array} + * @memberof V1beta1PodSecurityPolicySpec + */ + allowedFlexVolumes?: V1beta1AllowedFlexVolume[]; + /** + * allowedHostPaths is a white list of allowed host paths. Empty indicates that all host paths may be used. + * @type {Array} + * @memberof V1beta1PodSecurityPolicySpec + */ + allowedHostPaths?: V1beta1AllowedHostPath[]; + /** + * allowedUnsafeSysctls is a list of explicitly allowed unsafe sysctls, defaults to none. Each entry is either a plain sysctl name or ends in \"*\" in which case it is considered as a prefix of allowed sysctls. Single * means all unsafe sysctls are allowed. Kubelet has to whitelist all allowed unsafe sysctls explicitly to avoid rejection. Examples: e.g. \"foo/_*\" allows \"foo/bar\", \"foo/baz\", etc. e.g. \"foo.*\" allows \"foo.bar\", \"foo.baz\", etc. + * @type {Array} + * @memberof V1beta1PodSecurityPolicySpec + */ + allowedUnsafeSysctls?: string[]; + /** + * defaultAddCapabilities is the default set of capabilities that will be added to the container unless the pod spec specifically drops the capability. You may not list a capability in both defaultAddCapabilities and requiredDropCapabilities. Capabilities added here are implicitly allowed, and need not be included in the allowedCapabilities list. + * @type {Array} + * @memberof V1beta1PodSecurityPolicySpec + */ + defaultAddCapabilities?: string[]; + /** + * defaultAllowPrivilegeEscalation controls the default setting for whether a process can gain more privileges than its parent process. + * @type {boolean} + * @memberof V1beta1PodSecurityPolicySpec + */ + defaultAllowPrivilegeEscalation?: boolean; + /** + * forbiddenSysctls is a list of explicitly forbidden sysctls, defaults to none. Each entry is either a plain sysctl name or ends in \"*\" in which case it is considered as a prefix of forbidden sysctls. Single * means all sysctls are forbidden. Examples: e.g. \"foo/_*\" forbids \"foo/bar\", \"foo/baz\", etc. e.g. \"foo.*\" forbids \"foo.bar\", \"foo.baz\", etc. + * @type {Array} + * @memberof V1beta1PodSecurityPolicySpec + */ + forbiddenSysctls?: string[]; + /** + * + * @type {V1beta1FSGroupStrategyOptions} + * @memberof V1beta1PodSecurityPolicySpec + */ + fsGroup: V1beta1FSGroupStrategyOptions; + /** + * hostIPC determines if the policy allows the use of HostIPC in the pod spec. + * @type {boolean} + * @memberof V1beta1PodSecurityPolicySpec + */ + hostIPC?: boolean; + /** + * hostNetwork determines if the policy allows the use of HostNetwork in the pod spec. + * @type {boolean} + * @memberof V1beta1PodSecurityPolicySpec + */ + hostNetwork?: boolean; + /** + * hostPID determines if the policy allows the use of HostPID in the pod spec. + * @type {boolean} + * @memberof V1beta1PodSecurityPolicySpec + */ + hostPID?: boolean; + /** + * hostPorts determines which host port ranges are allowed to be exposed. + * @type {Array} + * @memberof V1beta1PodSecurityPolicySpec + */ + hostPorts?: V1beta1HostPortRange[]; + /** + * privileged determines if a pod can request to be run as privileged. + * @type {boolean} + * @memberof V1beta1PodSecurityPolicySpec + */ + privileged?: boolean; + /** + * readOnlyRootFilesystem when set to true will force containers to run with a read only root file system. If the container specifically requests to run with a non-read only root file system the PSP should deny the pod. If set to false the container may run with a read only root file system if it wishes but it will not be forced to. + * @type {boolean} + * @memberof V1beta1PodSecurityPolicySpec + */ + readOnlyRootFilesystem?: boolean; + /** + * requiredDropCapabilities are the capabilities that will be dropped from the container. These are required to be dropped and cannot be added. + * @type {Array} + * @memberof V1beta1PodSecurityPolicySpec + */ + requiredDropCapabilities?: string[]; + /** + * + * @type {V1beta1RunAsUserStrategyOptions} + * @memberof V1beta1PodSecurityPolicySpec + */ + runAsUser: V1beta1RunAsUserStrategyOptions; + /** + * + * @type {V1beta1SELinuxStrategyOptions} + * @memberof V1beta1PodSecurityPolicySpec + */ + seLinux: V1beta1SELinuxStrategyOptions; + /** + * + * @type {V1beta1SupplementalGroupsStrategyOptions} + * @memberof V1beta1PodSecurityPolicySpec + */ + supplementalGroups: V1beta1SupplementalGroupsStrategyOptions; + /** + * volumes is a white list of allowed volume plugins. Empty indicates that no volumes may be used. To allow all volumes you may use \'*\'. + * @type {Array} + * @memberof V1beta1PodSecurityPolicySpec + */ + volumes?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1PolicyRule.ts b/frontend/packages/kube-types/src/openshift/V1beta1PolicyRule.ts new file mode 100644 index 00000000000..a71a0e82405 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1PolicyRule.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PolicyRule holds information that describes a policy rule, but does not contain information about who the rule applies to or which namespace the rule applies to. + * @export + * @interface V1beta1PolicyRule + */ +export interface V1beta1PolicyRule { + /** + * APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. + * @type {Array} + * @memberof V1beta1PolicyRule + */ + apiGroups?: string[]; + /** + * NonResourceURLs is a set of partial urls that a user should have access to. *s are allowed, but only as the full, final step in the path Since non-resource URLs are not namespaced, this field is only applicable for ClusterRoles referenced from a ClusterRoleBinding. Rules can either apply to API resources (such as \"pods\" or \"secrets\") or non-resource URL paths (such as \"/api\"), but not both. + * @type {Array} + * @memberof V1beta1PolicyRule + */ + nonResourceURLs?: string[]; + /** + * ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. + * @type {Array} + * @memberof V1beta1PolicyRule + */ + resourceNames?: string[]; + /** + * Resources is a list of resources this rule applies to. \'*\' represents all resources in the specified apiGroups. \'*_/foo\' represents the subresource \'foo\' for all resources in the specified apiGroups. + * @type {Array} + * @memberof V1beta1PolicyRule + */ + resources?: string[]; + /** + * Verbs is a list of Verbs that apply to ALL the ResourceKinds and AttributeRestrictions contained in this rule. VerbAll represents all kinds. + * @type {Array} + * @memberof V1beta1PolicyRule + */ + verbs: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1PriorityClass.ts b/frontend/packages/kube-types/src/openshift/V1beta1PriorityClass.ts new file mode 100644 index 00000000000..60d38cca502 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1PriorityClass.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer. + * @export + * @interface V1beta1PriorityClass + */ +export interface V1beta1PriorityClass { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1PriorityClass + */ + apiVersion?: string; + /** + * description is an arbitrary string that usually provides guidelines on when this priority class should be used. + * @type {string} + * @memberof V1beta1PriorityClass + */ + description?: string; + /** + * globalDefault specifies whether this PriorityClass should be considered as the default priority for pods that do not have any priority class. Only one PriorityClass can be marked as `globalDefault`. However, if more than one PriorityClasses exists with their `globalDefault` field set to true, the smallest value of such global default PriorityClasses will be used as the default priority. + * @type {boolean} + * @memberof V1beta1PriorityClass + */ + globalDefault?: boolean; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1PriorityClass + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1PriorityClass + */ + metadata?: V1ObjectMeta; + /** + * The value of this priority class. This is the actual priority that pods receive when they have the name of this class in their pod spec. + * @type {number} + * @memberof V1beta1PriorityClass + */ + value: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1PriorityClassList.ts b/frontend/packages/kube-types/src/openshift/V1beta1PriorityClassList.ts new file mode 100644 index 00000000000..18049e83a45 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1PriorityClassList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1PriorityClass } from './V1beta1PriorityClass'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * PriorityClassList is a collection of priority classes. + * @export + * @interface V1beta1PriorityClassList + */ +export interface V1beta1PriorityClassList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1PriorityClassList + */ + apiVersion?: string; + /** + * items is the list of PriorityClasses + * @type {Array} + * @memberof V1beta1PriorityClassList + */ + items: V1beta1PriorityClass[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1PriorityClassList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1PriorityClassList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ResourceAttributes.ts b/frontend/packages/kube-types/src/openshift/V1beta1ResourceAttributes.ts new file mode 100644 index 00000000000..f96d88aa625 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ResourceAttributes.ts @@ -0,0 +1,62 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ResourceAttributes includes the authorization attributes available for resource requests to the Authorizer interface + * @export + * @interface V1beta1ResourceAttributes + */ +export interface V1beta1ResourceAttributes { + /** + * Group is the API Group of the Resource. \"*\" means all. + * @type {string} + * @memberof V1beta1ResourceAttributes + */ + group?: string; + /** + * Name is the name of the resource being requested for a \"get\" or deleted for a \"delete\". \"\" (empty) means all. + * @type {string} + * @memberof V1beta1ResourceAttributes + */ + name?: string; + /** + * Namespace is the namespace of the action being requested. Currently, there is no distinction between no namespace and all namespaces \"\" (empty) is defaulted for LocalSubjectAccessReviews \"\" (empty) is empty for cluster-scoped resources \"\" (empty) means \"all\" for namespace scoped resources from a SubjectAccessReview or SelfSubjectAccessReview + * @type {string} + * @memberof V1beta1ResourceAttributes + */ + namespace?: string; + /** + * Resource is one of the existing resource types. \"*\" means all. + * @type {string} + * @memberof V1beta1ResourceAttributes + */ + resource?: string; + /** + * Subresource is one of the existing resource types. \"\" means none. + * @type {string} + * @memberof V1beta1ResourceAttributes + */ + subresource?: string; + /** + * Verb is a kubernetes resource API verb, like: get, list, watch, create, update, delete, proxy. \"*\" means all. + * @type {string} + * @memberof V1beta1ResourceAttributes + */ + verb?: string; + /** + * Version is the API Version of the Resource. \"*\" means all. + * @type {string} + * @memberof V1beta1ResourceAttributes + */ + version?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ResourceRule.ts b/frontend/packages/kube-types/src/openshift/V1beta1ResourceRule.ts new file mode 100644 index 00000000000..b20c98dd1b9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ResourceRule.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ResourceRule is the list of actions the subject is allowed to perform on resources. The list ordering isn\'t significant, may contain duplicates, and possibly be incomplete. + * @export + * @interface V1beta1ResourceRule + */ +export interface V1beta1ResourceRule { + /** + * APIGroups is the name of the APIGroup that contains the resources. If multiple API groups are specified, any action requested against one of the enumerated resources in any API group will be allowed. \"*\" means all. + * @type {Array} + * @memberof V1beta1ResourceRule + */ + apiGroups?: string[]; + /** + * ResourceNames is an optional white list of names that the rule applies to. An empty set means that everything is allowed. \"*\" means all. + * @type {Array} + * @memberof V1beta1ResourceRule + */ + resourceNames?: string[]; + /** + * Resources is a list of resources this rule applies to. \"*\" means all in the specified apiGroups. \"*_/foo\" represents the subresource \'foo\' for all resources in the specified apiGroups. + * @type {Array} + * @memberof V1beta1ResourceRule + */ + resources?: string[]; + /** + * Verb is a list of kubernetes resource API verbs, like: get, list, watch, create, update, delete, proxy. \"*\" means all. + * @type {Array} + * @memberof V1beta1ResourceRule + */ + verbs: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1Role.ts b/frontend/packages/kube-types/src/openshift/V1beta1Role.ts new file mode 100644 index 00000000000..e67d7f9c78d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1Role.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1PolicyRule } from './V1beta1PolicyRule'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding. + * @export + * @interface V1beta1Role + */ +export interface V1beta1Role { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1Role + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1Role + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1Role + */ + metadata?: V1ObjectMeta; + /** + * Rules holds all the PolicyRules for this Role + * @type {Array} + * @memberof V1beta1Role + */ + rules: V1beta1PolicyRule[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1RoleBinding.ts b/frontend/packages/kube-types/src/openshift/V1beta1RoleBinding.ts new file mode 100644 index 00000000000..9eff5fd72bd --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1RoleBinding.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1RoleRef } from './V1beta1RoleRef'; +import { V1beta1Subject } from './V1beta1Subject'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * RoleBinding references a role, but does not contain it. It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in. RoleBindings in a given namespace only have effect in that namespace. + * @export + * @interface V1beta1RoleBinding + */ +export interface V1beta1RoleBinding { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1RoleBinding + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1RoleBinding + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1RoleBinding + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1RoleRef} + * @memberof V1beta1RoleBinding + */ + roleRef: V1beta1RoleRef; + /** + * Subjects holds references to the objects the role applies to. + * @type {Array} + * @memberof V1beta1RoleBinding + */ + subjects?: V1beta1Subject[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1RoleBindingList.ts b/frontend/packages/kube-types/src/openshift/V1beta1RoleBindingList.ts new file mode 100644 index 00000000000..eb878ea4baa --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1RoleBindingList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1RoleBinding } from './V1beta1RoleBinding'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * RoleBindingList is a collection of RoleBindings + * @export + * @interface V1beta1RoleBindingList + */ +export interface V1beta1RoleBindingList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1RoleBindingList + */ + apiVersion?: string; + /** + * Items is a list of RoleBindings + * @type {Array} + * @memberof V1beta1RoleBindingList + */ + items: V1beta1RoleBinding[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1RoleBindingList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1RoleBindingList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1RoleList.ts b/frontend/packages/kube-types/src/openshift/V1beta1RoleList.ts new file mode 100644 index 00000000000..ecb556f3ca4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1RoleList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1Role } from './V1beta1Role'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * RoleList is a collection of Roles + * @export + * @interface V1beta1RoleList + */ +export interface V1beta1RoleList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1RoleList + */ + apiVersion?: string; + /** + * Items is a list of Roles + * @type {Array} + * @memberof V1beta1RoleList + */ + items: V1beta1Role[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1RoleList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1RoleList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1RoleRef.ts b/frontend/packages/kube-types/src/openshift/V1beta1RoleRef.ts new file mode 100644 index 00000000000..f06b722cdae --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1RoleRef.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RoleRef contains information that points to the role being used + * @export + * @interface V1beta1RoleRef + */ +export interface V1beta1RoleRef { + /** + * APIGroup is the group for the resource being referenced + * @type {string} + * @memberof V1beta1RoleRef + */ + apiGroup: string; + /** + * Kind is the type of resource being referenced + * @type {string} + * @memberof V1beta1RoleRef + */ + kind: string; + /** + * Name is the name of resource being referenced + * @type {string} + * @memberof V1beta1RoleRef + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1RollbackConfig.ts b/frontend/packages/kube-types/src/openshift/V1beta1RollbackConfig.ts new file mode 100644 index 00000000000..7da6aad5ac8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1RollbackConfig.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DEPRECATED. + * @export + * @interface V1beta1RollbackConfig + */ +export interface V1beta1RollbackConfig { + /** + * The revision to rollback to. If set to 0, rollback to the last revision. + * @type {number} + * @memberof V1beta1RollbackConfig + */ + revision?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1RollingUpdateDeployment.ts b/frontend/packages/kube-types/src/openshift/V1beta1RollingUpdateDeployment.ts new file mode 100644 index 00000000000..8f2216d6957 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1RollingUpdateDeployment.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Spec to control the desired behavior of rolling update. + * @export + * @interface V1beta1RollingUpdateDeployment + */ +export interface V1beta1RollingUpdateDeployment { + /** + * + * @type {string} + * @memberof V1beta1RollingUpdateDeployment + */ + maxSurge?: string; + /** + * + * @type {string} + * @memberof V1beta1RollingUpdateDeployment + */ + maxUnavailable?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1RollingUpdateStatefulSetStrategy.ts b/frontend/packages/kube-types/src/openshift/V1beta1RollingUpdateStatefulSetStrategy.ts new file mode 100644 index 00000000000..e51c957c21f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1RollingUpdateStatefulSetStrategy.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. + * @export + * @interface V1beta1RollingUpdateStatefulSetStrategy + */ +export interface V1beta1RollingUpdateStatefulSetStrategy { + /** + * Partition indicates the ordinal at which the StatefulSet should be partitioned. + * @type {number} + * @memberof V1beta1RollingUpdateStatefulSetStrategy + */ + partition?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1RuleWithOperations.ts b/frontend/packages/kube-types/src/openshift/V1beta1RuleWithOperations.ts new file mode 100644 index 00000000000..29594497e7e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1RuleWithOperations.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RuleWithOperations is a tuple of Operations and Resources. It is recommended to make sure that all the tuple expansions are valid. + * @export + * @interface V1beta1RuleWithOperations + */ +export interface V1beta1RuleWithOperations { + /** + * APIGroups is the API groups the resources belong to. \'*\' is all groups. If \'*\' is present, the length of the slice must be one. Required. + * @type {Array} + * @memberof V1beta1RuleWithOperations + */ + apiGroups?: string[]; + /** + * APIVersions is the API versions the resources belong to. \'*\' is all versions. If \'*\' is present, the length of the slice must be one. Required. + * @type {Array} + * @memberof V1beta1RuleWithOperations + */ + apiVersions?: string[]; + /** + * Operations is the operations the admission hook cares about - CREATE, UPDATE, or * for all operations. If \'*\' is present, the length of the slice must be one. Required. + * @type {Array} + * @memberof V1beta1RuleWithOperations + */ + operations?: string[]; + /** + * Resources is a list of resources this rule applies to. For example: \'pods\' means pods. \'pods/log\' means the log subresource of pods. \'*\' means all resources, but not subresources. \'pods/_*\' means all subresources of pods. \'*_/scale\' means all scale subresources. \'*_/_*\' means all resources and their subresources. If wildcard is present, the validation rule will ensure resources do not overlap with each other. Depending on the enclosing object, subresources might not be allowed. Required. + * @type {Array} + * @memberof V1beta1RuleWithOperations + */ + resources?: string[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1RunAsUserStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/V1beta1RunAsUserStrategyOptions.ts new file mode 100644 index 00000000000..5a5bad3b939 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1RunAsUserStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1IDRange } from './V1beta1IDRange'; + +/** + * RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy. + * @export + * @interface V1beta1RunAsUserStrategyOptions + */ +export interface V1beta1RunAsUserStrategyOptions { + /** + * ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs. + * @type {Array} + * @memberof V1beta1RunAsUserStrategyOptions + */ + ranges?: V1beta1IDRange[]; + /** + * rule is the strategy that will dictate the allowable RunAsUser values that may be set. + * @type {string} + * @memberof V1beta1RunAsUserStrategyOptions + */ + rule: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1SELinuxStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/V1beta1SELinuxStrategyOptions.ts new file mode 100644 index 00000000000..71775651032 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1SELinuxStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1SELinuxOptions } from './V1SELinuxOptions'; + +/** + * SELinuxStrategyOptions defines the strategy type and any options used to create the strategy. + * @export + * @interface V1beta1SELinuxStrategyOptions + */ +export interface V1beta1SELinuxStrategyOptions { + /** + * rule is the strategy that will dictate the allowable labels that may be set. + * @type {string} + * @memberof V1beta1SELinuxStrategyOptions + */ + rule: string; + /** + * + * @type {V1SELinuxOptions} + * @memberof V1beta1SELinuxStrategyOptions + */ + seLinuxOptions?: V1SELinuxOptions; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1Scale.ts b/frontend/packages/kube-types/src/openshift/V1beta1Scale.ts new file mode 100644 index 00000000000..ecd2d51745e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1Scale.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1ScaleSpec } from './V1beta1ScaleSpec'; +import { V1beta1ScaleStatus } from './V1beta1ScaleStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Scale represents a scaling request for a resource. + * @export + * @interface V1beta1Scale + */ +export interface V1beta1Scale { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1Scale + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1Scale + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1Scale + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1ScaleSpec} + * @memberof V1beta1Scale + */ + spec?: V1beta1ScaleSpec; + /** + * + * @type {V1beta1ScaleStatus} + * @memberof V1beta1Scale + */ + status?: V1beta1ScaleStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ScaleSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1ScaleSpec.ts new file mode 100644 index 00000000000..5e4126f6319 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ScaleSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ScaleSpec describes the attributes of a scale subresource + * @export + * @interface V1beta1ScaleSpec + */ +export interface V1beta1ScaleSpec { + /** + * desired number of instances for the scaled object. + * @type {number} + * @memberof V1beta1ScaleSpec + */ + replicas?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ScaleStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta1ScaleStatus.ts new file mode 100644 index 00000000000..1de6bae416c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ScaleStatus.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ScaleStatus represents the current status of a scale subresource. + * @export + * @interface V1beta1ScaleStatus + */ +export interface V1beta1ScaleStatus { + /** + * actual number of observed instances of the scaled object. + * @type {number} + * @memberof V1beta1ScaleStatus + */ + replicas: number; + /** + * label query over pods that should match the replicas count. More info: http://kubernetes.io/docs/user-guide/labels#label-selectors + * @type {{ [key: string]: string; }} + * @memberof V1beta1ScaleStatus + */ + selector?: { [key: string]: string }; + /** + * label selector for pods that should match the replicas count. This is a serializated version of both map-based and more expressive set-based selectors. This is done to avoid introspection in the clients. The string will be in the same format as the query-param syntax. If the target type only supports map-based selectors, both this field and map-based selector field are populated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors + * @type {string} + * @memberof V1beta1ScaleStatus + */ + targetSelector?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectAccessReview.ts b/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectAccessReview.ts new file mode 100644 index 00000000000..8c6d08601f6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectAccessReview.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1SelfSubjectAccessReviewSpec } from './V1beta1SelfSubjectAccessReviewSpec'; +import { V1beta1SubjectAccessReviewStatus } from './V1beta1SubjectAccessReviewStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * SelfSubjectAccessReview checks whether or the current user can perform an action. Not filling in a spec.namespace means \"in all namespaces\". Self is a special case, because users should always be able to check whether they can perform an action + * @export + * @interface V1beta1SelfSubjectAccessReview + */ +export interface V1beta1SelfSubjectAccessReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1SelfSubjectAccessReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1SelfSubjectAccessReview + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1SelfSubjectAccessReview + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1SelfSubjectAccessReviewSpec} + * @memberof V1beta1SelfSubjectAccessReview + */ + spec: V1beta1SelfSubjectAccessReviewSpec; + /** + * + * @type {V1beta1SubjectAccessReviewStatus} + * @memberof V1beta1SelfSubjectAccessReview + */ + status?: V1beta1SubjectAccessReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectAccessReviewSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectAccessReviewSpec.ts new file mode 100644 index 00000000000..3ec9b8a8ac4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectAccessReviewSpec.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1NonResourceAttributes } from './V1beta1NonResourceAttributes'; +import { V1beta1ResourceAttributes } from './V1beta1ResourceAttributes'; + +/** + * SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set + * @export + * @interface V1beta1SelfSubjectAccessReviewSpec + */ +export interface V1beta1SelfSubjectAccessReviewSpec { + /** + * + * @type {V1beta1NonResourceAttributes} + * @memberof V1beta1SelfSubjectAccessReviewSpec + */ + nonResourceAttributes?: V1beta1NonResourceAttributes; + /** + * + * @type {V1beta1ResourceAttributes} + * @memberof V1beta1SelfSubjectAccessReviewSpec + */ + resourceAttributes?: V1beta1ResourceAttributes; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectRulesReview.ts b/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectRulesReview.ts new file mode 100644 index 00000000000..cb3db27885b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectRulesReview.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1SelfSubjectRulesReviewSpec } from './V1beta1SelfSubjectRulesReviewSpec'; +import { V1beta1SubjectRulesReviewStatus } from './V1beta1SubjectRulesReviewStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * SelfSubjectRulesReview enumerates the set of actions the current user can perform within a namespace. The returned list of actions may be incomplete depending on the server\'s authorization mode, and any errors experienced during the evaluation. SelfSubjectRulesReview should be used by UIs to show/hide actions, or to quickly let an end user reason about their permissions. It should NOT Be used by external systems to drive authorization decisions as this raises confused deputy, cache lifetime/revocation, and correctness concerns. SubjectAccessReview, and LocalAccessReview are the correct way to defer authorization decisions to the API server. + * @export + * @interface V1beta1SelfSubjectRulesReview + */ +export interface V1beta1SelfSubjectRulesReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1SelfSubjectRulesReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1SelfSubjectRulesReview + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1SelfSubjectRulesReview + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1SelfSubjectRulesReviewSpec} + * @memberof V1beta1SelfSubjectRulesReview + */ + spec: V1beta1SelfSubjectRulesReviewSpec; + /** + * + * @type {V1beta1SubjectRulesReviewStatus} + * @memberof V1beta1SelfSubjectRulesReview + */ + status?: V1beta1SubjectRulesReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectRulesReviewSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectRulesReviewSpec.ts new file mode 100644 index 00000000000..ab36e49a0a4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1SelfSubjectRulesReviewSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1beta1SelfSubjectRulesReviewSpec + */ +export interface V1beta1SelfSubjectRulesReviewSpec { + /** + * Namespace to evaluate rules for. Required. + * @type {string} + * @memberof V1beta1SelfSubjectRulesReviewSpec + */ + namespace?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ServiceReference.ts b/frontend/packages/kube-types/src/openshift/V1beta1ServiceReference.ts new file mode 100644 index 00000000000..9aabb30ef4e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ServiceReference.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ServiceReference holds a reference to Service.legacy.k8s.io + * @export + * @interface V1beta1ServiceReference + */ +export interface V1beta1ServiceReference { + /** + * `name` is the name of the service. Required + * @type {string} + * @memberof V1beta1ServiceReference + */ + name: string; + /** + * `namespace` is the namespace of the service. Required + * @type {string} + * @memberof V1beta1ServiceReference + */ + namespace: string; + /** + * `path` is an optional URL path which will be sent in any request to this service. + * @type {string} + * @memberof V1beta1ServiceReference + */ + path?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1StatefulSet.ts b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSet.ts new file mode 100644 index 00000000000..027157e9f42 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSet.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1StatefulSetSpec } from './V1beta1StatefulSetSpec'; +import { V1beta1StatefulSetStatus } from './V1beta1StatefulSetStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * DEPRECATED - This group version of StatefulSet is deprecated by apps/v1beta2/StatefulSet. See the release notes for more information. StatefulSet represents a set of pods with consistent identities. Identities are defined as: - Network: A single stable DNS and hostname. - Storage: As many VolumeClaims as requested. The StatefulSet guarantees that a given network identity will always map to the same storage identity. + * @export + * @interface V1beta1StatefulSet + */ +export interface V1beta1StatefulSet { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1StatefulSet + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1StatefulSet + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1StatefulSet + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1StatefulSetSpec} + * @memberof V1beta1StatefulSet + */ + spec?: V1beta1StatefulSetSpec; + /** + * + * @type {V1beta1StatefulSetStatus} + * @memberof V1beta1StatefulSet + */ + status?: V1beta1StatefulSetStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetCondition.ts b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetCondition.ts new file mode 100644 index 00000000000..1ca9939789e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * StatefulSetCondition describes the state of a statefulset at a certain point. + * @export + * @interface V1beta1StatefulSetCondition + */ +export interface V1beta1StatefulSetCondition { + /** + * + * @type {string} + * @memberof V1beta1StatefulSetCondition + */ + lastTransitionTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof V1beta1StatefulSetCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof V1beta1StatefulSetCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1beta1StatefulSetCondition + */ + status: string; + /** + * Type of statefulset condition. + * @type {string} + * @memberof V1beta1StatefulSetCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetList.ts b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetList.ts new file mode 100644 index 00000000000..fd585005b68 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1StatefulSet } from './V1beta1StatefulSet'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * StatefulSetList is a collection of StatefulSets. + * @export + * @interface V1beta1StatefulSetList + */ +export interface V1beta1StatefulSetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1StatefulSetList + */ + apiVersion?: string; + /** + * + * @type {Array} + * @memberof V1beta1StatefulSetList + */ + items: V1beta1StatefulSet[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1StatefulSetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1StatefulSetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetSpec.ts new file mode 100644 index 00000000000..853f1b84b5c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetSpec.ts @@ -0,0 +1,73 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1StatefulSetUpdateStrategy } from './V1beta1StatefulSetUpdateStrategy'; +import { V1PersistentVolumeClaim } from './V1PersistentVolumeClaim'; +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * A StatefulSetSpec is the specification of a StatefulSet. + * @export + * @interface V1beta1StatefulSetSpec + */ +export interface V1beta1StatefulSetSpec { + /** + * podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once. + * @type {string} + * @memberof V1beta1StatefulSetSpec + */ + podManagementPolicy?: string; + /** + * replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1. + * @type {number} + * @memberof V1beta1StatefulSetSpec + */ + replicas?: number; + /** + * revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet\'s revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10. + * @type {number} + * @memberof V1beta1StatefulSetSpec + */ + revisionHistoryLimit?: number; + /** + * + * @type {V1LabelSelector} + * @memberof V1beta1StatefulSetSpec + */ + selector?: V1LabelSelector; + /** + * serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller. + * @type {string} + * @memberof V1beta1StatefulSetSpec + */ + serviceName: string; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1beta1StatefulSetSpec + */ + template: V1PodTemplateSpec; + /** + * + * @type {V1beta1StatefulSetUpdateStrategy} + * @memberof V1beta1StatefulSetSpec + */ + updateStrategy?: V1beta1StatefulSetUpdateStrategy; + /** + * volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name. + * @type {Array} + * @memberof V1beta1StatefulSetSpec + */ + volumeClaimTemplates?: V1PersistentVolumeClaim[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetStatus.ts new file mode 100644 index 00000000000..f95cbdff3c9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetStatus.ts @@ -0,0 +1,76 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1StatefulSetCondition } from './V1beta1StatefulSetCondition'; + +/** + * StatefulSetStatus represents the current state of a StatefulSet. + * @export + * @interface V1beta1StatefulSetStatus + */ +export interface V1beta1StatefulSetStatus { + /** + * collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. + * @type {number} + * @memberof V1beta1StatefulSetStatus + */ + collisionCount?: number; + /** + * Represents the latest available observations of a statefulset\'s current state. + * @type {Array} + * @memberof V1beta1StatefulSetStatus + */ + conditions?: V1beta1StatefulSetCondition[]; + /** + * currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision. + * @type {number} + * @memberof V1beta1StatefulSetStatus + */ + currentReplicas?: number; + /** + * currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas). + * @type {string} + * @memberof V1beta1StatefulSetStatus + */ + currentRevision?: string; + /** + * observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet\'s generation, which is updated on mutation by the API Server. + * @type {number} + * @memberof V1beta1StatefulSetStatus + */ + observedGeneration?: number; + /** + * readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. + * @type {number} + * @memberof V1beta1StatefulSetStatus + */ + readyReplicas?: number; + /** + * replicas is the number of Pods created by the StatefulSet controller. + * @type {number} + * @memberof V1beta1StatefulSetStatus + */ + replicas: number; + /** + * updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas) + * @type {string} + * @memberof V1beta1StatefulSetStatus + */ + updateRevision?: string; + /** + * updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision. + * @type {number} + * @memberof V1beta1StatefulSetStatus + */ + updatedReplicas?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetUpdateStrategy.ts b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetUpdateStrategy.ts new file mode 100644 index 00000000000..1aca8e29ece --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1StatefulSetUpdateStrategy.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1RollingUpdateStatefulSetStrategy } from './V1beta1RollingUpdateStatefulSetStrategy'; + +/** + * StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. + * @export + * @interface V1beta1StatefulSetUpdateStrategy + */ +export interface V1beta1StatefulSetUpdateStrategy { + /** + * + * @type {V1beta1RollingUpdateStatefulSetStrategy} + * @memberof V1beta1StatefulSetUpdateStrategy + */ + rollingUpdate?: V1beta1RollingUpdateStatefulSetStrategy; + /** + * Type indicates the type of the StatefulSetUpdateStrategy. + * @type {string} + * @memberof V1beta1StatefulSetUpdateStrategy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1StorageClass.ts b/frontend/packages/kube-types/src/openshift/V1beta1StorageClass.ts new file mode 100644 index 00000000000..aac3c613ec4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1StorageClass.ts @@ -0,0 +1,83 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1TopologySelectorTerm } from './V1TopologySelectorTerm'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * StorageClass describes the parameters for a class of storage for which PersistentVolumes can be dynamically provisioned. StorageClasses are non-namespaced; the name of the storage class according to etcd is in ObjectMeta.Name. + * @export + * @interface V1beta1StorageClass + */ +export interface V1beta1StorageClass { + /** + * AllowVolumeExpansion shows whether the storage class allow volume expand + * @type {boolean} + * @memberof V1beta1StorageClass + */ + allowVolumeExpansion?: boolean; + /** + * Restrict the node topologies where volumes can be dynamically provisioned. Each volume plugin defines its own supported topology specifications. An empty TopologySelectorTerm list means there is no topology restriction. This field is alpha-level and is only honored by servers that enable the DynamicProvisioningScheduling feature. + * @type {Array} + * @memberof V1beta1StorageClass + */ + allowedTopologies?: V1TopologySelectorTerm[]; + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1StorageClass + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1StorageClass + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1StorageClass + */ + metadata?: V1ObjectMeta; + /** + * Dynamically provisioned PersistentVolumes of this storage class are created with these mountOptions, e.g. [\"ro\", \"soft\"]. Not validated - mount of the PVs will simply fail if one is invalid. + * @type {Array} + * @memberof V1beta1StorageClass + */ + mountOptions?: string[]; + /** + * Parameters holds the parameters for the provisioner that should create volumes of this storage class. + * @type {{ [key: string]: string; }} + * @memberof V1beta1StorageClass + */ + parameters?: { [key: string]: string }; + /** + * Provisioner indicates the type of the provisioner. + * @type {string} + * @memberof V1beta1StorageClass + */ + provisioner: string; + /** + * Dynamically provisioned PersistentVolumes of this storage class are created with this reclaimPolicy. Defaults to Delete. + * @type {string} + * @memberof V1beta1StorageClass + */ + reclaimPolicy?: string; + /** + * VolumeBindingMode indicates how PersistentVolumeClaims should be provisioned and bound. When unset, VolumeBindingImmediate is used. This field is alpha-level and is only honored by servers that enable the VolumeScheduling feature. + * @type {string} + * @memberof V1beta1StorageClass + */ + volumeBindingMode?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1StorageClassList.ts b/frontend/packages/kube-types/src/openshift/V1beta1StorageClassList.ts new file mode 100644 index 00000000000..6f6755296fd --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1StorageClassList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1StorageClass } from './V1beta1StorageClass'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * StorageClassList is a collection of storage classes. + * @export + * @interface V1beta1StorageClassList + */ +export interface V1beta1StorageClassList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1StorageClassList + */ + apiVersion?: string; + /** + * Items is the list of StorageClasses + * @type {Array} + * @memberof V1beta1StorageClassList + */ + items: V1beta1StorageClass[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1StorageClassList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1StorageClassList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1Subject.ts b/frontend/packages/kube-types/src/openshift/V1beta1Subject.ts new file mode 100644 index 00000000000..a9612406bee --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1Subject.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names. + * @export + * @interface V1beta1Subject + */ +export interface V1beta1Subject { + /** + * APIGroup holds the API group of the referenced subject. Defaults to \"\" for ServiceAccount subjects. Defaults to \"rbac.authorization.k8s.io\" for User and Group subjects. + * @type {string} + * @memberof V1beta1Subject + */ + apiGroup?: string; + /** + * Kind of object being referenced. Values defined by this API group are \"User\", \"Group\", and \"ServiceAccount\". If the Authorizer does not recognized the kind value, the Authorizer should report an error. + * @type {string} + * @memberof V1beta1Subject + */ + kind: string; + /** + * Name of the object being referenced. + * @type {string} + * @memberof V1beta1Subject + */ + name: string; + /** + * Namespace of the referenced object. If the object kind is non-namespace, such as \"User\" or \"Group\", and this value is not empty the Authorizer should report an error. + * @type {string} + * @memberof V1beta1Subject + */ + namespace?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReview.ts b/frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReview.ts new file mode 100644 index 00000000000..c54bf17350d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReview.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1SubjectAccessReviewSpec } from './V1beta1SubjectAccessReviewSpec'; +import { V1beta1SubjectAccessReviewStatus } from './V1beta1SubjectAccessReviewStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * SubjectAccessReview checks whether or not a user or group can perform an action. + * @export + * @interface V1beta1SubjectAccessReview + */ +export interface V1beta1SubjectAccessReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1SubjectAccessReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1SubjectAccessReview + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1SubjectAccessReview + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1SubjectAccessReviewSpec} + * @memberof V1beta1SubjectAccessReview + */ + spec: V1beta1SubjectAccessReviewSpec; + /** + * + * @type {V1beta1SubjectAccessReviewStatus} + * @memberof V1beta1SubjectAccessReview + */ + status?: V1beta1SubjectAccessReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReviewSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReviewSpec.ts new file mode 100644 index 00000000000..cfdcf691c38 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReviewSpec.ts @@ -0,0 +1,59 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1NonResourceAttributes } from './V1beta1NonResourceAttributes'; +import { V1beta1ResourceAttributes } from './V1beta1ResourceAttributes'; + +/** + * SubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set + * @export + * @interface V1beta1SubjectAccessReviewSpec + */ +export interface V1beta1SubjectAccessReviewSpec { + /** + * Extra corresponds to the user.Info.GetExtra() method from the authenticator. Since that is input to the authorizer it needs a reflection here. + * @type {{ [key: string]: Array; }} + * @memberof V1beta1SubjectAccessReviewSpec + */ + extra?: { [key: string]: string[] }; + /** + * Groups is the groups you\'re testing for. + * @type {Array} + * @memberof V1beta1SubjectAccessReviewSpec + */ + group?: string[]; + /** + * + * @type {V1beta1NonResourceAttributes} + * @memberof V1beta1SubjectAccessReviewSpec + */ + nonResourceAttributes?: V1beta1NonResourceAttributes; + /** + * + * @type {V1beta1ResourceAttributes} + * @memberof V1beta1SubjectAccessReviewSpec + */ + resourceAttributes?: V1beta1ResourceAttributes; + /** + * UID information about the requesting user. + * @type {string} + * @memberof V1beta1SubjectAccessReviewSpec + */ + uid?: string; + /** + * User is the user you\'re testing for. If you specify \"User\" but not \"Group\", then is it interpreted as \"What if User were not a member of any groups + * @type {string} + * @memberof V1beta1SubjectAccessReviewSpec + */ + user?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReviewStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReviewStatus.ts new file mode 100644 index 00000000000..a9f5ef74f8d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1SubjectAccessReviewStatus.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SubjectAccessReviewStatus + * @export + * @interface V1beta1SubjectAccessReviewStatus + */ +export interface V1beta1SubjectAccessReviewStatus { + /** + * Allowed is required. True if the action would be allowed, false otherwise. + * @type {boolean} + * @memberof V1beta1SubjectAccessReviewStatus + */ + allowed: boolean; + /** + * Denied is optional. True if the action would be denied, otherwise false. If both allowed is false and denied is false, then the authorizer has no opinion on whether to authorize the action. Denied may not be true if Allowed is true. + * @type {boolean} + * @memberof V1beta1SubjectAccessReviewStatus + */ + denied?: boolean; + /** + * EvaluationError is an indication that some error occurred during the authorization check. It is entirely possible to get an error and be able to continue determine authorization status in spite of it. For instance, RBAC can be missing a role, but enough roles are still present and bound to reason about the request. + * @type {string} + * @memberof V1beta1SubjectAccessReviewStatus + */ + evaluationError?: string; + /** + * Reason is optional. It indicates why a request was allowed or denied. + * @type {string} + * @memberof V1beta1SubjectAccessReviewStatus + */ + reason?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1SubjectRulesReviewStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta1SubjectRulesReviewStatus.ts new file mode 100644 index 00000000000..b8d50379378 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1SubjectRulesReviewStatus.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1NonResourceRule } from './V1beta1NonResourceRule'; +import { V1beta1ResourceRule } from './V1beta1ResourceRule'; + +/** + * SubjectRulesReviewStatus contains the result of a rules check. This check can be incomplete depending on the set of authorizers the server is configured with and any errors experienced during evaluation. Because authorization rules are additive, if a rule appears in a list it\'s safe to assume the subject has that permission, even if that list is incomplete. + * @export + * @interface V1beta1SubjectRulesReviewStatus + */ +export interface V1beta1SubjectRulesReviewStatus { + /** + * EvaluationError can appear in combination with Rules. It indicates an error occurred during rule evaluation, such as an authorizer that doesn\'t support rule evaluation, and that ResourceRules and/or NonResourceRules may be incomplete. + * @type {string} + * @memberof V1beta1SubjectRulesReviewStatus + */ + evaluationError?: string; + /** + * Incomplete is true when the rules returned by this call are incomplete. This is most commonly encountered when an authorizer, such as an external authorizer, doesn\'t support rules evaluation. + * @type {boolean} + * @memberof V1beta1SubjectRulesReviewStatus + */ + incomplete: boolean; + /** + * NonResourceRules is the list of actions the subject is allowed to perform on non-resources. The list ordering isn\'t significant, may contain duplicates, and possibly be incomplete. + * @type {Array} + * @memberof V1beta1SubjectRulesReviewStatus + */ + nonResourceRules: V1beta1NonResourceRule[]; + /** + * ResourceRules is the list of actions the subject is allowed to perform on resources. The list ordering isn\'t significant, may contain duplicates, and possibly be incomplete. + * @type {Array} + * @memberof V1beta1SubjectRulesReviewStatus + */ + resourceRules: V1beta1ResourceRule[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1SupplementalGroupsStrategyOptions.ts b/frontend/packages/kube-types/src/openshift/V1beta1SupplementalGroupsStrategyOptions.ts new file mode 100644 index 00000000000..987b6ce57a9 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1SupplementalGroupsStrategyOptions.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1IDRange } from './V1beta1IDRange'; + +/** + * SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy. + * @export + * @interface V1beta1SupplementalGroupsStrategyOptions + */ +export interface V1beta1SupplementalGroupsStrategyOptions { + /** + * ranges are the allowed ranges of supplemental groups. If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs. + * @type {Array} + * @memberof V1beta1SupplementalGroupsStrategyOptions + */ + ranges?: V1beta1IDRange[]; + /** + * rule is the strategy that will dictate what supplemental groups is used in the SecurityContext. + * @type {string} + * @memberof V1beta1SupplementalGroupsStrategyOptions + */ + rule?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1TokenReview.ts b/frontend/packages/kube-types/src/openshift/V1beta1TokenReview.ts new file mode 100644 index 00000000000..ce2c874a6b8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1TokenReview.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1TokenReviewSpec } from './V1beta1TokenReviewSpec'; +import { V1beta1TokenReviewStatus } from './V1beta1TokenReviewStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * TokenReview attempts to authenticate a token to a known user. Note: TokenReview requests may be cached by the webhook token authenticator plugin in the kube-apiserver. + * @export + * @interface V1beta1TokenReview + */ +export interface V1beta1TokenReview { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1TokenReview + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1TokenReview + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1TokenReview + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1TokenReviewSpec} + * @memberof V1beta1TokenReview + */ + spec: V1beta1TokenReviewSpec; + /** + * + * @type {V1beta1TokenReviewStatus} + * @memberof V1beta1TokenReview + */ + status?: V1beta1TokenReviewStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1TokenReviewSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1TokenReviewSpec.ts new file mode 100644 index 00000000000..95e78273fb0 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1TokenReviewSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TokenReviewSpec is a description of the token authentication request. + * @export + * @interface V1beta1TokenReviewSpec + */ +export interface V1beta1TokenReviewSpec { + /** + * Token is the opaque bearer token. + * @type {string} + * @memberof V1beta1TokenReviewSpec + */ + token?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1TokenReviewStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta1TokenReviewStatus.ts new file mode 100644 index 00000000000..9a7e028688a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1TokenReviewStatus.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1UserInfo } from './V1beta1UserInfo'; + +/** + * TokenReviewStatus is the result of the token authentication request. + * @export + * @interface V1beta1TokenReviewStatus + */ +export interface V1beta1TokenReviewStatus { + /** + * Authenticated indicates that the token was associated with a known user. + * @type {boolean} + * @memberof V1beta1TokenReviewStatus + */ + authenticated?: boolean; + /** + * Error indicates that the token couldn\'t be checked + * @type {string} + * @memberof V1beta1TokenReviewStatus + */ + error?: string; + /** + * + * @type {V1beta1UserInfo} + * @memberof V1beta1TokenReviewStatus + */ + user?: V1beta1UserInfo; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1UserInfo.ts b/frontend/packages/kube-types/src/openshift/V1beta1UserInfo.ts new file mode 100644 index 00000000000..7356376361f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1UserInfo.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * UserInfo holds the information about the user needed to implement the user.Info interface. + * @export + * @interface V1beta1UserInfo + */ +export interface V1beta1UserInfo { + /** + * Any additional information provided by the authenticator. + * @type {{ [key: string]: Array; }} + * @memberof V1beta1UserInfo + */ + extra?: { [key: string]: string[] }; + /** + * The names of groups this user is a part of. + * @type {Array} + * @memberof V1beta1UserInfo + */ + groups?: string[]; + /** + * A unique value that identifies this user across time. If this user is deleted and another user by the same name is added, they will have different UIDs. + * @type {string} + * @memberof V1beta1UserInfo + */ + uid?: string; + /** + * The name that uniquely identifies this user among all active users. + * @type {string} + * @memberof V1beta1UserInfo + */ + username?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ValidatingWebhookConfiguration.ts b/frontend/packages/kube-types/src/openshift/V1beta1ValidatingWebhookConfiguration.ts new file mode 100644 index 00000000000..e92666b79d7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ValidatingWebhookConfiguration.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1Webhook } from './V1beta1Webhook'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * ValidatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and object without changing it. + * @export + * @interface V1beta1ValidatingWebhookConfiguration + */ +export interface V1beta1ValidatingWebhookConfiguration { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1ValidatingWebhookConfiguration + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1ValidatingWebhookConfiguration + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1ValidatingWebhookConfiguration + */ + metadata?: V1ObjectMeta; + /** + * Webhooks is a list of webhooks and the affected resources and operations. + * @type {Array} + * @memberof V1beta1ValidatingWebhookConfiguration + */ + webhooks?: V1beta1Webhook[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1ValidatingWebhookConfigurationList.ts b/frontend/packages/kube-types/src/openshift/V1beta1ValidatingWebhookConfigurationList.ts new file mode 100644 index 00000000000..298aceada5e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1ValidatingWebhookConfigurationList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1ValidatingWebhookConfiguration } from './V1beta1ValidatingWebhookConfiguration'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ValidatingWebhookConfigurationList is a list of ValidatingWebhookConfiguration. + * @export + * @interface V1beta1ValidatingWebhookConfigurationList + */ +export interface V1beta1ValidatingWebhookConfigurationList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1ValidatingWebhookConfigurationList + */ + apiVersion?: string; + /** + * List of ValidatingWebhookConfiguration. + * @type {Array} + * @memberof V1beta1ValidatingWebhookConfigurationList + */ + items: V1beta1ValidatingWebhookConfiguration[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1ValidatingWebhookConfigurationList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1ValidatingWebhookConfigurationList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachment.ts b/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachment.ts new file mode 100644 index 00000000000..968b521f571 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachment.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1VolumeAttachmentSpec } from './V1beta1VolumeAttachmentSpec'; +import { V1beta1VolumeAttachmentStatus } from './V1beta1VolumeAttachmentStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. VolumeAttachment objects are non-namespaced. + * @export + * @interface V1beta1VolumeAttachment + */ +export interface V1beta1VolumeAttachment { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1VolumeAttachment + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1VolumeAttachment + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta1VolumeAttachment + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta1VolumeAttachmentSpec} + * @memberof V1beta1VolumeAttachment + */ + spec: V1beta1VolumeAttachmentSpec; + /** + * + * @type {V1beta1VolumeAttachmentStatus} + * @memberof V1beta1VolumeAttachment + */ + status?: V1beta1VolumeAttachmentStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentList.ts b/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentList.ts new file mode 100644 index 00000000000..4042d71dcbf --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1VolumeAttachment } from './V1beta1VolumeAttachment'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * VolumeAttachmentList is a collection of VolumeAttachment objects. + * @export + * @interface V1beta1VolumeAttachmentList + */ +export interface V1beta1VolumeAttachmentList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta1VolumeAttachmentList + */ + apiVersion?: string; + /** + * Items is the list of VolumeAttachments + * @type {Array} + * @memberof V1beta1VolumeAttachmentList + */ + items: V1beta1VolumeAttachment[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta1VolumeAttachmentList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta1VolumeAttachmentList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentSource.ts b/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentSource.ts new file mode 100644 index 00000000000..e8fa213fc97 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentSource.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * VolumeAttachmentSource represents a volume that should be attached. Right now only PersistenVolumes can be attached via external attacher, in future we may allow also inline volumes in pods. Exactly one member can be set. + * @export + * @interface V1beta1VolumeAttachmentSource + */ +export interface V1beta1VolumeAttachmentSource { + /** + * Name of the persistent volume to attach. + * @type {string} + * @memberof V1beta1VolumeAttachmentSource + */ + persistentVolumeName?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentSpec.ts new file mode 100644 index 00000000000..e1207f846b5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentSpec.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1VolumeAttachmentSource } from './V1beta1VolumeAttachmentSource'; + +/** + * VolumeAttachmentSpec is the specification of a VolumeAttachment request. + * @export + * @interface V1beta1VolumeAttachmentSpec + */ +export interface V1beta1VolumeAttachmentSpec { + /** + * Attacher indicates the name of the volume driver that MUST handle this request. This is the name returned by GetPluginName(). + * @type {string} + * @memberof V1beta1VolumeAttachmentSpec + */ + attacher: string; + /** + * The node that the volume should be attached to. + * @type {string} + * @memberof V1beta1VolumeAttachmentSpec + */ + nodeName: string; + /** + * + * @type {V1beta1VolumeAttachmentSource} + * @memberof V1beta1VolumeAttachmentSpec + */ + source: V1beta1VolumeAttachmentSource; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentStatus.ts new file mode 100644 index 00000000000..6e276fdf853 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1VolumeAttachmentStatus.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1VolumeError } from './V1beta1VolumeError'; + +/** + * VolumeAttachmentStatus is the status of a VolumeAttachment request. + * @export + * @interface V1beta1VolumeAttachmentStatus + */ +export interface V1beta1VolumeAttachmentStatus { + /** + * + * @type {V1beta1VolumeError} + * @memberof V1beta1VolumeAttachmentStatus + */ + attachError?: V1beta1VolumeError; + /** + * Indicates the volume is successfully attached. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. + * @type {boolean} + * @memberof V1beta1VolumeAttachmentStatus + */ + attached: boolean; + /** + * Upon successful attach, this field is populated with any information returned by the attach operation that must be passed into subsequent WaitForAttach or Mount calls. This field must only be set by the entity completing the attach operation, i.e. the external-attacher. + * @type {{ [key: string]: string; }} + * @memberof V1beta1VolumeAttachmentStatus + */ + attachmentMetadata?: { [key: string]: string }; + /** + * + * @type {V1beta1VolumeError} + * @memberof V1beta1VolumeAttachmentStatus + */ + detachError?: V1beta1VolumeError; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1VolumeError.ts b/frontend/packages/kube-types/src/openshift/V1beta1VolumeError.ts new file mode 100644 index 00000000000..b04afccbdda --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1VolumeError.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * VolumeError captures an error encountered during a volume operation. + * @export + * @interface V1beta1VolumeError + */ +export interface V1beta1VolumeError { + /** + * String detailing the error encountered during Attach or Detach operation. This string maybe logged, so it should not contain sensitive information. + * @type {string} + * @memberof V1beta1VolumeError + */ + message?: string; + /** + * + * @type {string} + * @memberof V1beta1VolumeError + */ + time?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1Webhook.ts b/frontend/packages/kube-types/src/openshift/V1beta1Webhook.ts new file mode 100644 index 00000000000..97517fb1100 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1Webhook.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1RuleWithOperations } from './V1beta1RuleWithOperations'; +import { V1beta1WebhookClientConfig } from './V1beta1WebhookClientConfig'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * Webhook describes an admission webhook and the resources and operations it applies to. + * @export + * @interface V1beta1Webhook + */ +export interface V1beta1Webhook { + /** + * + * @type {V1beta1WebhookClientConfig} + * @memberof V1beta1Webhook + */ + clientConfig: V1beta1WebhookClientConfig; + /** + * FailurePolicy defines how unrecognized errors from the admission endpoint are handled - allowed values are Ignore or Fail. Defaults to Ignore. + * @type {string} + * @memberof V1beta1Webhook + */ + failurePolicy?: string; + /** + * The name of the admission webhook. Name should be fully qualified, e.g., imagepolicy.kubernetes.io, where \"imagepolicy\" is the name of the webhook, and kubernetes.io is the name of the organization. Required. + * @type {string} + * @memberof V1beta1Webhook + */ + name: string; + /** + * + * @type {V1LabelSelector} + * @memberof V1beta1Webhook + */ + namespaceSelector?: V1LabelSelector; + /** + * Rules describes what operations on what resources/subresources the webhook cares about. The webhook cares about an operation if it matches _any_ Rule. However, in order to prevent ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks from putting the cluster in a state which cannot be recovered from without completely disabling the plugin, ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks are never called on admission requests for ValidatingWebhookConfiguration and MutatingWebhookConfiguration objects. + * @type {Array} + * @memberof V1beta1Webhook + */ + rules?: V1beta1RuleWithOperations[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta1WebhookClientConfig.ts b/frontend/packages/kube-types/src/openshift/V1beta1WebhookClientConfig.ts new file mode 100644 index 00000000000..8de0477f954 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta1WebhookClientConfig.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta1ServiceReference } from './V1beta1ServiceReference'; + +/** + * WebhookClientConfig contains the information to make a TLS connection with the webhook + * @export + * @interface V1beta1WebhookClientConfig + */ +export interface V1beta1WebhookClientConfig { + /** + * `caBundle` is a PEM encoded CA bundle which will be used to validate the webhook\'s server certificate. Required. + * @type {string} + * @memberof V1beta1WebhookClientConfig + */ + caBundle: string; + /** + * + * @type {V1beta1ServiceReference} + * @memberof V1beta1WebhookClientConfig + */ + service?: V1beta1ServiceReference; + /** + * `url` gives the location of the webhook, in standard URL form (`[scheme://]host:port/path`). Exactly one of `url` or `service` must be specified. The `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address. Please note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster. The scheme must be \"https\"; the URL must begin with \"https://\". A path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier. Attempting to use a user or basic auth e.g. \"user:password@\" is not allowed. Fragments (\"#...\") and query parameters (\"?...\") are not allowed, either. + * @type {string} + * @memberof V1beta1WebhookClientConfig + */ + url?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2ControllerRevision.ts b/frontend/packages/kube-types/src/openshift/V1beta2ControllerRevision.ts new file mode 100644 index 00000000000..5766417406c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2ControllerRevision.ts @@ -0,0 +1,53 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { IoK8sApimachineryPkgRuntimeRawExtension } from './IoK8sApimachineryPkgRuntimeRawExtension'; + +/** + * DEPRECATED - This group version of ControllerRevision is deprecated by apps/v1/ControllerRevision. See the release notes for more information. ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers. + * @export + * @interface V1beta2ControllerRevision + */ +export interface V1beta2ControllerRevision { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta2ControllerRevision + */ + apiVersion?: string; + /** + * + * @type {IoK8sApimachineryPkgRuntimeRawExtension} + * @memberof V1beta2ControllerRevision + */ + data?: IoK8sApimachineryPkgRuntimeRawExtension; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta2ControllerRevision + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta2ControllerRevision + */ + metadata?: V1ObjectMeta; + /** + * Revision indicates the revision of the state represented by Data. + * @type {number} + * @memberof V1beta2ControllerRevision + */ + revision: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2ControllerRevisionList.ts b/frontend/packages/kube-types/src/openshift/V1beta2ControllerRevisionList.ts new file mode 100644 index 00000000000..fed2f26ba8a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2ControllerRevisionList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2ControllerRevision } from './V1beta2ControllerRevision'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ControllerRevisionList is a resource containing a list of ControllerRevision objects. + * @export + * @interface V1beta2ControllerRevisionList + */ +export interface V1beta2ControllerRevisionList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta2ControllerRevisionList + */ + apiVersion?: string; + /** + * Items is the list of ControllerRevisions + * @type {Array} + * @memberof V1beta2ControllerRevisionList + */ + items: V1beta2ControllerRevision[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta2ControllerRevisionList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta2ControllerRevisionList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2DaemonSet.ts b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSet.ts new file mode 100644 index 00000000000..1ce8490a0ad --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSet.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2DaemonSetSpec } from './V1beta2DaemonSetSpec'; +import { V1beta2DaemonSetStatus } from './V1beta2DaemonSetStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * DEPRECATED - This group version of DaemonSet is deprecated by apps/v1/DaemonSet. See the release notes for more information. DaemonSet represents the configuration of a daemon set. + * @export + * @interface V1beta2DaemonSet + */ +export interface V1beta2DaemonSet { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta2DaemonSet + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta2DaemonSet + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta2DaemonSet + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta2DaemonSetSpec} + * @memberof V1beta2DaemonSet + */ + spec?: V1beta2DaemonSetSpec; + /** + * + * @type {V1beta2DaemonSetStatus} + * @memberof V1beta2DaemonSet + */ + status?: V1beta2DaemonSetStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetCondition.ts b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetCondition.ts new file mode 100644 index 00000000000..3fe4a62655a --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DaemonSetCondition describes the state of a DaemonSet at a certain point. + * @export + * @interface V1beta2DaemonSetCondition + */ +export interface V1beta2DaemonSetCondition { + /** + * + * @type {string} + * @memberof V1beta2DaemonSetCondition + */ + lastTransitionTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof V1beta2DaemonSetCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof V1beta2DaemonSetCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1beta2DaemonSetCondition + */ + status: string; + /** + * Type of DaemonSet condition. + * @type {string} + * @memberof V1beta2DaemonSetCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetList.ts b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetList.ts new file mode 100644 index 00000000000..a918b6f23e5 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2DaemonSet } from './V1beta2DaemonSet'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * DaemonSetList is a collection of daemon sets. + * @export + * @interface V1beta2DaemonSetList + */ +export interface V1beta2DaemonSetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta2DaemonSetList + */ + apiVersion?: string; + /** + * A list of daemon sets. + * @type {Array} + * @memberof V1beta2DaemonSetList + */ + items: V1beta2DaemonSet[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta2DaemonSetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta2DaemonSetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetSpec.ts new file mode 100644 index 00000000000..e08fde9076b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetSpec.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2DaemonSetUpdateStrategy } from './V1beta2DaemonSetUpdateStrategy'; +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * DaemonSetSpec is the specification of a daemon set. + * @export + * @interface V1beta2DaemonSetSpec + */ +export interface V1beta2DaemonSetSpec { + /** + * The minimum number of seconds for which a newly created DaemonSet pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready). + * @type {number} + * @memberof V1beta2DaemonSetSpec + */ + minReadySeconds?: number; + /** + * The number of old history to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. + * @type {number} + * @memberof V1beta2DaemonSetSpec + */ + revisionHistoryLimit?: number; + /** + * + * @type {V1LabelSelector} + * @memberof V1beta2DaemonSetSpec + */ + selector: V1LabelSelector; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1beta2DaemonSetSpec + */ + template: V1PodTemplateSpec; + /** + * + * @type {V1beta2DaemonSetUpdateStrategy} + * @memberof V1beta2DaemonSetSpec + */ + updateStrategy?: V1beta2DaemonSetUpdateStrategy; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetStatus.ts new file mode 100644 index 00000000000..eeaabf23b3f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetStatus.ts @@ -0,0 +1,82 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2DaemonSetCondition } from './V1beta2DaemonSetCondition'; + +/** + * DaemonSetStatus represents the current status of a daemon set. + * @export + * @interface V1beta2DaemonSetStatus + */ +export interface V1beta2DaemonSetStatus { + /** + * Count of hash collisions for the DaemonSet. The DaemonSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. + * @type {number} + * @memberof V1beta2DaemonSetStatus + */ + collisionCount?: number; + /** + * Represents the latest available observations of a DaemonSet\'s current state. + * @type {Array} + * @memberof V1beta2DaemonSetStatus + */ + conditions?: V1beta2DaemonSetCondition[]; + /** + * The number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ + * @type {number} + * @memberof V1beta2DaemonSetStatus + */ + currentNumberScheduled: number; + /** + * The total number of nodes that should be running the daemon pod (including nodes correctly running the daemon pod). More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ + * @type {number} + * @memberof V1beta2DaemonSetStatus + */ + desiredNumberScheduled: number; + /** + * The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and available (ready for at least spec.minReadySeconds) + * @type {number} + * @memberof V1beta2DaemonSetStatus + */ + numberAvailable?: number; + /** + * The number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. More info: https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/ + * @type {number} + * @memberof V1beta2DaemonSetStatus + */ + numberMisscheduled: number; + /** + * The number of nodes that should be running the daemon pod and have one or more of the daemon pod running and ready. + * @type {number} + * @memberof V1beta2DaemonSetStatus + */ + numberReady: number; + /** + * The number of nodes that should be running the daemon pod and have none of the daemon pod running and available (ready for at least spec.minReadySeconds) + * @type {number} + * @memberof V1beta2DaemonSetStatus + */ + numberUnavailable?: number; + /** + * The most recent generation observed by the daemon set controller. + * @type {number} + * @memberof V1beta2DaemonSetStatus + */ + observedGeneration?: number; + /** + * The total number of nodes that are running updated daemon pod + * @type {number} + * @memberof V1beta2DaemonSetStatus + */ + updatedNumberScheduled?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetUpdateStrategy.ts b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetUpdateStrategy.ts new file mode 100644 index 00000000000..55b4e76f02e --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2DaemonSetUpdateStrategy.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2RollingUpdateDaemonSet } from './V1beta2RollingUpdateDaemonSet'; + +/** + * DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet. + * @export + * @interface V1beta2DaemonSetUpdateStrategy + */ +export interface V1beta2DaemonSetUpdateStrategy { + /** + * + * @type {V1beta2RollingUpdateDaemonSet} + * @memberof V1beta2DaemonSetUpdateStrategy + */ + rollingUpdate?: V1beta2RollingUpdateDaemonSet; + /** + * Type of daemon set update. Can be \"RollingUpdate\" or \"OnDelete\". Default is RollingUpdate. + * @type {string} + * @memberof V1beta2DaemonSetUpdateStrategy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2Deployment.ts b/frontend/packages/kube-types/src/openshift/V1beta2Deployment.ts new file mode 100644 index 00000000000..9ae13df1614 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2Deployment.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2DeploymentSpec } from './V1beta2DeploymentSpec'; +import { V1beta2DeploymentStatus } from './V1beta2DeploymentStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * DEPRECATED - This group version of Deployment is deprecated by apps/v1/Deployment. See the release notes for more information. Deployment enables declarative updates for Pods and ReplicaSets. + * @export + * @interface V1beta2Deployment + */ +export interface V1beta2Deployment { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta2Deployment + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta2Deployment + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta2Deployment + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta2DeploymentSpec} + * @memberof V1beta2Deployment + */ + spec?: V1beta2DeploymentSpec; + /** + * + * @type {V1beta2DeploymentStatus} + * @memberof V1beta2Deployment + */ + status?: V1beta2DeploymentStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2DeploymentCondition.ts b/frontend/packages/kube-types/src/openshift/V1beta2DeploymentCondition.ts new file mode 100644 index 00000000000..892fc67ef16 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2DeploymentCondition.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DeploymentCondition describes the state of a deployment at a certain point. + * @export + * @interface V1beta2DeploymentCondition + */ +export interface V1beta2DeploymentCondition { + /** + * + * @type {string} + * @memberof V1beta2DeploymentCondition + */ + lastTransitionTime?: string; + /** + * + * @type {string} + * @memberof V1beta2DeploymentCondition + */ + lastUpdateTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof V1beta2DeploymentCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof V1beta2DeploymentCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1beta2DeploymentCondition + */ + status: string; + /** + * Type of deployment condition. + * @type {string} + * @memberof V1beta2DeploymentCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2DeploymentList.ts b/frontend/packages/kube-types/src/openshift/V1beta2DeploymentList.ts new file mode 100644 index 00000000000..073c44a2429 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2DeploymentList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2Deployment } from './V1beta2Deployment'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * DeploymentList is a list of Deployments. + * @export + * @interface V1beta2DeploymentList + */ +export interface V1beta2DeploymentList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta2DeploymentList + */ + apiVersion?: string; + /** + * Items is the list of Deployments. + * @type {Array} + * @memberof V1beta2DeploymentList + */ + items: V1beta2Deployment[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta2DeploymentList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta2DeploymentList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2DeploymentSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta2DeploymentSpec.ts new file mode 100644 index 00000000000..09f3ca8901f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2DeploymentSpec.ts @@ -0,0 +1,72 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2DeploymentStrategy } from './V1beta2DeploymentStrategy'; +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * DeploymentSpec is the specification of the desired behavior of the Deployment. + * @export + * @interface V1beta2DeploymentSpec + */ +export interface V1beta2DeploymentSpec { + /** + * Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) + * @type {number} + * @memberof V1beta2DeploymentSpec + */ + minReadySeconds?: number; + /** + * Indicates that the deployment is paused. + * @type {boolean} + * @memberof V1beta2DeploymentSpec + */ + paused?: boolean; + /** + * The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s. + * @type {number} + * @memberof V1beta2DeploymentSpec + */ + progressDeadlineSeconds?: number; + /** + * Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. + * @type {number} + * @memberof V1beta2DeploymentSpec + */ + replicas?: number; + /** + * The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10. + * @type {number} + * @memberof V1beta2DeploymentSpec + */ + revisionHistoryLimit?: number; + /** + * + * @type {V1LabelSelector} + * @memberof V1beta2DeploymentSpec + */ + selector: V1LabelSelector; + /** + * + * @type {V1beta2DeploymentStrategy} + * @memberof V1beta2DeploymentSpec + */ + strategy?: V1beta2DeploymentStrategy; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1beta2DeploymentSpec + */ + template: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2DeploymentStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta2DeploymentStatus.ts new file mode 100644 index 00000000000..1a24d843543 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2DeploymentStatus.ts @@ -0,0 +1,70 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2DeploymentCondition } from './V1beta2DeploymentCondition'; + +/** + * DeploymentStatus is the most recently observed status of the Deployment. + * @export + * @interface V1beta2DeploymentStatus + */ +export interface V1beta2DeploymentStatus { + /** + * Total number of available pods (ready for at least minReadySeconds) targeted by this deployment. + * @type {number} + * @memberof V1beta2DeploymentStatus + */ + availableReplicas?: number; + /** + * Count of hash collisions for the Deployment. The Deployment controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ReplicaSet. + * @type {number} + * @memberof V1beta2DeploymentStatus + */ + collisionCount?: number; + /** + * Represents the latest available observations of a deployment\'s current state. + * @type {Array} + * @memberof V1beta2DeploymentStatus + */ + conditions?: V1beta2DeploymentCondition[]; + /** + * The generation observed by the deployment controller. + * @type {number} + * @memberof V1beta2DeploymentStatus + */ + observedGeneration?: number; + /** + * Total number of ready pods targeted by this deployment. + * @type {number} + * @memberof V1beta2DeploymentStatus + */ + readyReplicas?: number; + /** + * Total number of non-terminated pods targeted by this deployment (their labels match the selector). + * @type {number} + * @memberof V1beta2DeploymentStatus + */ + replicas?: number; + /** + * Total number of unavailable pods targeted by this deployment. This is the total number of pods that are still required for the deployment to have 100% available capacity. They may either be pods that are running but not yet available or pods that still have not been created. + * @type {number} + * @memberof V1beta2DeploymentStatus + */ + unavailableReplicas?: number; + /** + * Total number of non-terminated pods targeted by this deployment that have the desired template spec. + * @type {number} + * @memberof V1beta2DeploymentStatus + */ + updatedReplicas?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2DeploymentStrategy.ts b/frontend/packages/kube-types/src/openshift/V1beta2DeploymentStrategy.ts new file mode 100644 index 00000000000..fff3296ede6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2DeploymentStrategy.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2RollingUpdateDeployment } from './V1beta2RollingUpdateDeployment'; + +/** + * DeploymentStrategy describes how to replace existing pods with new ones. + * @export + * @interface V1beta2DeploymentStrategy + */ +export interface V1beta2DeploymentStrategy { + /** + * + * @type {V1beta2RollingUpdateDeployment} + * @memberof V1beta2DeploymentStrategy + */ + rollingUpdate?: V1beta2RollingUpdateDeployment; + /** + * Type of deployment. Can be \"Recreate\" or \"RollingUpdate\". Default is RollingUpdate. + * @type {string} + * @memberof V1beta2DeploymentStrategy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSet.ts b/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSet.ts new file mode 100644 index 00000000000..9bb07ce0f2c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSet.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2ReplicaSetSpec } from './V1beta2ReplicaSetSpec'; +import { V1beta2ReplicaSetStatus } from './V1beta2ReplicaSetStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * DEPRECATED - This group version of ReplicaSet is deprecated by apps/v1/ReplicaSet. See the release notes for more information. ReplicaSet ensures that a specified number of pod replicas are running at any given time. + * @export + * @interface V1beta2ReplicaSet + */ +export interface V1beta2ReplicaSet { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta2ReplicaSet + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta2ReplicaSet + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta2ReplicaSet + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta2ReplicaSetSpec} + * @memberof V1beta2ReplicaSet + */ + spec?: V1beta2ReplicaSetSpec; + /** + * + * @type {V1beta2ReplicaSetStatus} + * @memberof V1beta2ReplicaSet + */ + status?: V1beta2ReplicaSetStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetCondition.ts b/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetCondition.ts new file mode 100644 index 00000000000..a7b23c19d9b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ReplicaSetCondition describes the state of a replica set at a certain point. + * @export + * @interface V1beta2ReplicaSetCondition + */ +export interface V1beta2ReplicaSetCondition { + /** + * + * @type {string} + * @memberof V1beta2ReplicaSetCondition + */ + lastTransitionTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof V1beta2ReplicaSetCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof V1beta2ReplicaSetCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1beta2ReplicaSetCondition + */ + status: string; + /** + * Type of replica set condition. + * @type {string} + * @memberof V1beta2ReplicaSetCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetList.ts b/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetList.ts new file mode 100644 index 00000000000..54d0659fa45 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2ReplicaSet } from './V1beta2ReplicaSet'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * ReplicaSetList is a collection of ReplicaSets. + * @export + * @interface V1beta2ReplicaSetList + */ +export interface V1beta2ReplicaSetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta2ReplicaSetList + */ + apiVersion?: string; + /** + * List of ReplicaSets. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller + * @type {Array} + * @memberof V1beta2ReplicaSetList + */ + items: V1beta2ReplicaSet[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta2ReplicaSetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta2ReplicaSetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetSpec.ts new file mode 100644 index 00000000000..a03490fd70d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetSpec.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * ReplicaSetSpec is the specification of a ReplicaSet. + * @export + * @interface V1beta2ReplicaSetSpec + */ +export interface V1beta2ReplicaSetSpec { + /** + * Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) + * @type {number} + * @memberof V1beta2ReplicaSetSpec + */ + minReadySeconds?: number; + /** + * Replicas is the number of desired replicas. This is a pointer to distinguish between explicit zero and unspecified. Defaults to 1. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller + * @type {number} + * @memberof V1beta2ReplicaSetSpec + */ + replicas?: number; + /** + * + * @type {V1LabelSelector} + * @memberof V1beta2ReplicaSetSpec + */ + selector: V1LabelSelector; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1beta2ReplicaSetSpec + */ + template?: V1PodTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetStatus.ts new file mode 100644 index 00000000000..847e90d1e84 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2ReplicaSetStatus.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2ReplicaSetCondition } from './V1beta2ReplicaSetCondition'; + +/** + * ReplicaSetStatus represents the current status of a ReplicaSet. + * @export + * @interface V1beta2ReplicaSetStatus + */ +export interface V1beta2ReplicaSetStatus { + /** + * The number of available replicas (ready for at least minReadySeconds) for this replica set. + * @type {number} + * @memberof V1beta2ReplicaSetStatus + */ + availableReplicas?: number; + /** + * Represents the latest available observations of a replica set\'s current state. + * @type {Array} + * @memberof V1beta2ReplicaSetStatus + */ + conditions?: V1beta2ReplicaSetCondition[]; + /** + * The number of pods that have labels matching the labels of the pod template of the replicaset. + * @type {number} + * @memberof V1beta2ReplicaSetStatus + */ + fullyLabeledReplicas?: number; + /** + * ObservedGeneration reflects the generation of the most recently observed ReplicaSet. + * @type {number} + * @memberof V1beta2ReplicaSetStatus + */ + observedGeneration?: number; + /** + * The number of ready replicas for this replica set. + * @type {number} + * @memberof V1beta2ReplicaSetStatus + */ + readyReplicas?: number; + /** + * Replicas is the most recently oberved number of replicas. More info: https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller + * @type {number} + * @memberof V1beta2ReplicaSetStatus + */ + replicas: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateDaemonSet.ts b/frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateDaemonSet.ts new file mode 100644 index 00000000000..c199ceacf1b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateDaemonSet.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Spec to control the desired behavior of daemon set rolling update. + * @export + * @interface V1beta2RollingUpdateDaemonSet + */ +export interface V1beta2RollingUpdateDaemonSet { + /** + * + * @type {string} + * @memberof V1beta2RollingUpdateDaemonSet + */ + maxUnavailable?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateDeployment.ts b/frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateDeployment.ts new file mode 100644 index 00000000000..3588a15d586 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateDeployment.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Spec to control the desired behavior of rolling update. + * @export + * @interface V1beta2RollingUpdateDeployment + */ +export interface V1beta2RollingUpdateDeployment { + /** + * + * @type {string} + * @memberof V1beta2RollingUpdateDeployment + */ + maxSurge?: string; + /** + * + * @type {string} + * @memberof V1beta2RollingUpdateDeployment + */ + maxUnavailable?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateStatefulSetStrategy.ts b/frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateStatefulSetStrategy.ts new file mode 100644 index 00000000000..9651a6a81c8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2RollingUpdateStatefulSetStrategy.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType. + * @export + * @interface V1beta2RollingUpdateStatefulSetStrategy + */ +export interface V1beta2RollingUpdateStatefulSetStrategy { + /** + * Partition indicates the ordinal at which the StatefulSet should be partitioned. Default value is 0. + * @type {number} + * @memberof V1beta2RollingUpdateStatefulSetStrategy + */ + partition?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2Scale.ts b/frontend/packages/kube-types/src/openshift/V1beta2Scale.ts new file mode 100644 index 00000000000..672116edcd7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2Scale.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2ScaleSpec } from './V1beta2ScaleSpec'; +import { V1beta2ScaleStatus } from './V1beta2ScaleStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * Scale represents a scaling request for a resource. + * @export + * @interface V1beta2Scale + */ +export interface V1beta2Scale { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta2Scale + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta2Scale + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta2Scale + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta2ScaleSpec} + * @memberof V1beta2Scale + */ + spec?: V1beta2ScaleSpec; + /** + * + * @type {V1beta2ScaleStatus} + * @memberof V1beta2Scale + */ + status?: V1beta2ScaleStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2ScaleSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta2ScaleSpec.ts new file mode 100644 index 00000000000..21f60615b08 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2ScaleSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ScaleSpec describes the attributes of a scale subresource + * @export + * @interface V1beta2ScaleSpec + */ +export interface V1beta2ScaleSpec { + /** + * desired number of instances for the scaled object. + * @type {number} + * @memberof V1beta2ScaleSpec + */ + replicas?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2ScaleStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta2ScaleStatus.ts new file mode 100644 index 00000000000..32dde84044b --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2ScaleStatus.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ScaleStatus represents the current status of a scale subresource. + * @export + * @interface V1beta2ScaleStatus + */ +export interface V1beta2ScaleStatus { + /** + * actual number of observed instances of the scaled object. + * @type {number} + * @memberof V1beta2ScaleStatus + */ + replicas: number; + /** + * label query over pods that should match the replicas count. More info: http://kubernetes.io/docs/user-guide/labels#label-selectors + * @type {{ [key: string]: string; }} + * @memberof V1beta2ScaleStatus + */ + selector?: { [key: string]: string }; + /** + * label selector for pods that should match the replicas count. This is a serializated version of both map-based and more expressive set-based selectors. This is done to avoid introspection in the clients. The string will be in the same format as the query-param syntax. If the target type only supports map-based selectors, both this field and map-based selector field are populated. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors + * @type {string} + * @memberof V1beta2ScaleStatus + */ + targetSelector?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2StatefulSet.ts b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSet.ts new file mode 100644 index 00000000000..0c3d23dc37c --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSet.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2StatefulSetSpec } from './V1beta2StatefulSetSpec'; +import { V1beta2StatefulSetStatus } from './V1beta2StatefulSetStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * DEPRECATED - This group version of StatefulSet is deprecated by apps/v1/StatefulSet. See the release notes for more information. StatefulSet represents a set of pods with consistent identities. Identities are defined as: - Network: A single stable DNS and hostname. - Storage: As many VolumeClaims as requested. The StatefulSet guarantees that a given network identity will always map to the same storage identity. + * @export + * @interface V1beta2StatefulSet + */ +export interface V1beta2StatefulSet { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta2StatefulSet + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta2StatefulSet + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1beta2StatefulSet + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1beta2StatefulSetSpec} + * @memberof V1beta2StatefulSet + */ + spec?: V1beta2StatefulSetSpec; + /** + * + * @type {V1beta2StatefulSetStatus} + * @memberof V1beta2StatefulSet + */ + status?: V1beta2StatefulSetStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetCondition.ts b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetCondition.ts new file mode 100644 index 00000000000..9808e185fa8 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * StatefulSetCondition describes the state of a statefulset at a certain point. + * @export + * @interface V1beta2StatefulSetCondition + */ +export interface V1beta2StatefulSetCondition { + /** + * + * @type {string} + * @memberof V1beta2StatefulSetCondition + */ + lastTransitionTime?: string; + /** + * A human readable message indicating details about the transition. + * @type {string} + * @memberof V1beta2StatefulSetCondition + */ + message?: string; + /** + * The reason for the condition\'s last transition. + * @type {string} + * @memberof V1beta2StatefulSetCondition + */ + reason?: string; + /** + * Status of the condition, one of True, False, Unknown. + * @type {string} + * @memberof V1beta2StatefulSetCondition + */ + status: string; + /** + * Type of statefulset condition. + * @type {string} + * @memberof V1beta2StatefulSetCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetList.ts b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetList.ts new file mode 100644 index 00000000000..59aaa80dd16 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2StatefulSet } from './V1beta2StatefulSet'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * StatefulSetList is a collection of StatefulSets. + * @export + * @interface V1beta2StatefulSetList + */ +export interface V1beta2StatefulSetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1beta2StatefulSetList + */ + apiVersion?: string; + /** + * + * @type {Array} + * @memberof V1beta2StatefulSetList + */ + items: V1beta2StatefulSet[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1beta2StatefulSetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1beta2StatefulSetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetSpec.ts b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetSpec.ts new file mode 100644 index 00000000000..32a248b9627 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetSpec.ts @@ -0,0 +1,73 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2StatefulSetUpdateStrategy } from './V1beta2StatefulSetUpdateStrategy'; +import { V1PersistentVolumeClaim } from './V1PersistentVolumeClaim'; +import { V1PodTemplateSpec } from './V1PodTemplateSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * A StatefulSetSpec is the specification of a StatefulSet. + * @export + * @interface V1beta2StatefulSetSpec + */ +export interface V1beta2StatefulSetSpec { + /** + * podManagementPolicy controls how pods are created during initial scale up, when replacing pods on nodes, or when scaling down. The default policy is `OrderedReady`, where pods are created in increasing order (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before continuing. When scaling down, the pods are removed in the opposite order. The alternative policy is `Parallel` which will create pods in parallel to match the desired scale without waiting, and on scale down will delete all pods at once. + * @type {string} + * @memberof V1beta2StatefulSetSpec + */ + podManagementPolicy?: string; + /** + * replicas is the desired number of replicas of the given Template. These are replicas in the sense that they are instantiations of the same Template, but individual replicas also have a consistent identity. If unspecified, defaults to 1. + * @type {number} + * @memberof V1beta2StatefulSetSpec + */ + replicas?: number; + /** + * revisionHistoryLimit is the maximum number of revisions that will be maintained in the StatefulSet\'s revision history. The revision history consists of all revisions not represented by a currently applied StatefulSetSpec version. The default value is 10. + * @type {number} + * @memberof V1beta2StatefulSetSpec + */ + revisionHistoryLimit?: number; + /** + * + * @type {V1LabelSelector} + * @memberof V1beta2StatefulSetSpec + */ + selector: V1LabelSelector; + /** + * serviceName is the name of the service that governs this StatefulSet. This service must exist before the StatefulSet, and is responsible for the network identity of the set. Pods get DNS/hostnames that follow the pattern: pod-specific-string.serviceName.default.svc.cluster.local where \"pod-specific-string\" is managed by the StatefulSet controller. + * @type {string} + * @memberof V1beta2StatefulSetSpec + */ + serviceName: string; + /** + * + * @type {V1PodTemplateSpec} + * @memberof V1beta2StatefulSetSpec + */ + template: V1PodTemplateSpec; + /** + * + * @type {V1beta2StatefulSetUpdateStrategy} + * @memberof V1beta2StatefulSetSpec + */ + updateStrategy?: V1beta2StatefulSetUpdateStrategy; + /** + * volumeClaimTemplates is a list of claims that pods are allowed to reference. The StatefulSet controller is responsible for mapping network identities to claims in a way that maintains the identity of a pod. Every claim in this list must have at least one matching (by name) volumeMount in one container in the template. A claim in this list takes precedence over any volumes in the template, with the same name. + * @type {Array} + * @memberof V1beta2StatefulSetSpec + */ + volumeClaimTemplates?: V1PersistentVolumeClaim[]; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetStatus.ts b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetStatus.ts new file mode 100644 index 00000000000..5023de86990 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetStatus.ts @@ -0,0 +1,76 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2StatefulSetCondition } from './V1beta2StatefulSetCondition'; + +/** + * StatefulSetStatus represents the current state of a StatefulSet. + * @export + * @interface V1beta2StatefulSetStatus + */ +export interface V1beta2StatefulSetStatus { + /** + * collisionCount is the count of hash collisions for the StatefulSet. The StatefulSet controller uses this field as a collision avoidance mechanism when it needs to create the name for the newest ControllerRevision. + * @type {number} + * @memberof V1beta2StatefulSetStatus + */ + collisionCount?: number; + /** + * Represents the latest available observations of a statefulset\'s current state. + * @type {Array} + * @memberof V1beta2StatefulSetStatus + */ + conditions?: V1beta2StatefulSetCondition[]; + /** + * currentReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by currentRevision. + * @type {number} + * @memberof V1beta2StatefulSetStatus + */ + currentReplicas?: number; + /** + * currentRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [0,currentReplicas). + * @type {string} + * @memberof V1beta2StatefulSetStatus + */ + currentRevision?: string; + /** + * observedGeneration is the most recent generation observed for this StatefulSet. It corresponds to the StatefulSet\'s generation, which is updated on mutation by the API Server. + * @type {number} + * @memberof V1beta2StatefulSetStatus + */ + observedGeneration?: number; + /** + * readyReplicas is the number of Pods created by the StatefulSet controller that have a Ready Condition. + * @type {number} + * @memberof V1beta2StatefulSetStatus + */ + readyReplicas?: number; + /** + * replicas is the number of Pods created by the StatefulSet controller. + * @type {number} + * @memberof V1beta2StatefulSetStatus + */ + replicas: number; + /** + * updateRevision, if not empty, indicates the version of the StatefulSet used to generate Pods in the sequence [replicas-updatedReplicas,replicas) + * @type {string} + * @memberof V1beta2StatefulSetStatus + */ + updateRevision?: string; + /** + * updatedReplicas is the number of Pods created by the StatefulSet controller from the StatefulSet version indicated by updateRevision. + * @type {number} + * @memberof V1beta2StatefulSetStatus + */ + updatedReplicas?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetUpdateStrategy.ts b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetUpdateStrategy.ts new file mode 100644 index 00000000000..e8bbd27b81d --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V1beta2StatefulSetUpdateStrategy.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1beta2RollingUpdateStatefulSetStrategy } from './V1beta2RollingUpdateStatefulSetStrategy'; + +/** + * StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy. + * @export + * @interface V1beta2StatefulSetUpdateStrategy + */ +export interface V1beta2StatefulSetUpdateStrategy { + /** + * + * @type {V1beta2RollingUpdateStatefulSetStrategy} + * @memberof V1beta2StatefulSetUpdateStrategy + */ + rollingUpdate?: V1beta2RollingUpdateStatefulSetStrategy; + /** + * Type indicates the type of the StatefulSetUpdateStrategy. Default is RollingUpdate. + * @type {string} + * @memberof V1beta2StatefulSetUpdateStrategy + */ + type?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1CrossVersionObjectReference.ts b/frontend/packages/kube-types/src/openshift/V2beta1CrossVersionObjectReference.ts new file mode 100644 index 00000000000..3bd3314fe83 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1CrossVersionObjectReference.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * CrossVersionObjectReference contains enough information to let you identify the referred resource. + * @export + * @interface V2beta1CrossVersionObjectReference + */ +export interface V2beta1CrossVersionObjectReference { + /** + * API version of the referent + * @type {string} + * @memberof V2beta1CrossVersionObjectReference + */ + apiVersion?: string; + /** + * Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds\" + * @type {string} + * @memberof V2beta1CrossVersionObjectReference + */ + kind: string; + /** + * Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names + * @type {string} + * @memberof V2beta1CrossVersionObjectReference + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1ExternalMetricSource.ts b/frontend/packages/kube-types/src/openshift/V2beta1ExternalMetricSource.ts new file mode 100644 index 00000000000..af9bd4af6e6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1ExternalMetricSource.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * ExternalMetricSource indicates how to scale on a metric not associated with any Kubernetes object (for example length of queue in cloud messaging service, or QPS from loadbalancer running outside of cluster). Exactly one \"target\" type should be set. + * @export + * @interface V2beta1ExternalMetricSource + */ +export interface V2beta1ExternalMetricSource { + /** + * metricName is the name of the metric in question. + * @type {string} + * @memberof V2beta1ExternalMetricSource + */ + metricName: string; + /** + * + * @type {V1LabelSelector} + * @memberof V2beta1ExternalMetricSource + */ + metricSelector?: V1LabelSelector; + /** + * + * @type {string} + * @memberof V2beta1ExternalMetricSource + */ + targetAverageValue?: string; + /** + * + * @type {string} + * @memberof V2beta1ExternalMetricSource + */ + targetValue?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1ExternalMetricStatus.ts b/frontend/packages/kube-types/src/openshift/V2beta1ExternalMetricStatus.ts new file mode 100644 index 00000000000..18cea9c4963 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1ExternalMetricStatus.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * ExternalMetricStatus indicates the current value of a global metric not associated with any Kubernetes object. + * @export + * @interface V2beta1ExternalMetricStatus + */ +export interface V2beta1ExternalMetricStatus { + /** + * + * @type {string} + * @memberof V2beta1ExternalMetricStatus + */ + currentAverageValue?: string; + /** + * + * @type {string} + * @memberof V2beta1ExternalMetricStatus + */ + currentValue: string; + /** + * metricName is the name of a metric used for autoscaling in metric system. + * @type {string} + * @memberof V2beta1ExternalMetricStatus + */ + metricName: string; + /** + * + * @type {V1LabelSelector} + * @memberof V2beta1ExternalMetricStatus + */ + metricSelector?: V1LabelSelector; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscaler.ts b/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscaler.ts new file mode 100644 index 00000000000..f6364124998 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscaler.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V2beta1HorizontalPodAutoscalerSpec } from './V2beta1HorizontalPodAutoscalerSpec'; +import { V2beta1HorizontalPodAutoscalerStatus } from './V2beta1HorizontalPodAutoscalerStatus'; +import { V1ObjectMeta } from './V1ObjectMeta'; + +/** + * HorizontalPodAutoscaler is the configuration for a horizontal pod autoscaler, which automatically manages the replica count of any resource implementing the scale subresource based on the metrics specified. + * @export + * @interface V2beta1HorizontalPodAutoscaler + */ +export interface V2beta1HorizontalPodAutoscaler { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V2beta1HorizontalPodAutoscaler + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V2beta1HorizontalPodAutoscaler + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V2beta1HorizontalPodAutoscaler + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V2beta1HorizontalPodAutoscalerSpec} + * @memberof V2beta1HorizontalPodAutoscaler + */ + spec?: V2beta1HorizontalPodAutoscalerSpec; + /** + * + * @type {V2beta1HorizontalPodAutoscalerStatus} + * @memberof V2beta1HorizontalPodAutoscaler + */ + status?: V2beta1HorizontalPodAutoscalerStatus; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerCondition.ts b/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerCondition.ts new file mode 100644 index 00000000000..133e3a7bfca --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerCondition.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * HorizontalPodAutoscalerCondition describes the state of a HorizontalPodAutoscaler at a certain point. + * @export + * @interface V2beta1HorizontalPodAutoscalerCondition + */ +export interface V2beta1HorizontalPodAutoscalerCondition { + /** + * + * @type {string} + * @memberof V2beta1HorizontalPodAutoscalerCondition + */ + lastTransitionTime?: string; + /** + * message is a human-readable explanation containing details about the transition + * @type {string} + * @memberof V2beta1HorizontalPodAutoscalerCondition + */ + message?: string; + /** + * reason is the reason for the condition\'s last transition. + * @type {string} + * @memberof V2beta1HorizontalPodAutoscalerCondition + */ + reason?: string; + /** + * status is the status of the condition (True, False, Unknown) + * @type {string} + * @memberof V2beta1HorizontalPodAutoscalerCondition + */ + status: string; + /** + * type describes the current condition + * @type {string} + * @memberof V2beta1HorizontalPodAutoscalerCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerList.ts b/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerList.ts new file mode 100644 index 00000000000..6abe0700288 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V2beta1HorizontalPodAutoscaler } from './V2beta1HorizontalPodAutoscaler'; +import { V1ListMeta } from './V1ListMeta'; + +/** + * HorizontalPodAutoscaler is a list of horizontal pod autoscaler objects. + * @export + * @interface V2beta1HorizontalPodAutoscalerList + */ +export interface V2beta1HorizontalPodAutoscalerList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V2beta1HorizontalPodAutoscalerList + */ + apiVersion?: string; + /** + * items is the list of horizontal pod autoscaler objects. + * @type {Array} + * @memberof V2beta1HorizontalPodAutoscalerList + */ + items: V2beta1HorizontalPodAutoscaler[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V2beta1HorizontalPodAutoscalerList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V2beta1HorizontalPodAutoscalerList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerSpec.ts b/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerSpec.ts new file mode 100644 index 00000000000..7adfdc2bedc --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerSpec.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V2beta1CrossVersionObjectReference } from './V2beta1CrossVersionObjectReference'; +import { V2beta1MetricSpec } from './V2beta1MetricSpec'; + +/** + * HorizontalPodAutoscalerSpec describes the desired functionality of the HorizontalPodAutoscaler. + * @export + * @interface V2beta1HorizontalPodAutoscalerSpec + */ +export interface V2beta1HorizontalPodAutoscalerSpec { + /** + * maxReplicas is the upper limit for the number of replicas to which the autoscaler can scale up. It cannot be less that minReplicas. + * @type {number} + * @memberof V2beta1HorizontalPodAutoscalerSpec + */ + maxReplicas: number; + /** + * metrics contains the specifications for which to use to calculate the desired replica count (the maximum replica count across all metrics will be used). The desired replica count is calculated multiplying the ratio between the target value and the current value by the current number of pods. Ergo, metrics used must decrease as the pod count is increased, and vice-versa. See the individual metric source types for more information about how each type of metric must respond. + * @type {Array} + * @memberof V2beta1HorizontalPodAutoscalerSpec + */ + metrics?: V2beta1MetricSpec[]; + /** + * minReplicas is the lower limit for the number of replicas to which the autoscaler can scale down. It defaults to 1 pod. + * @type {number} + * @memberof V2beta1HorizontalPodAutoscalerSpec + */ + minReplicas?: number; + /** + * + * @type {V2beta1CrossVersionObjectReference} + * @memberof V2beta1HorizontalPodAutoscalerSpec + */ + scaleTargetRef: V2beta1CrossVersionObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerStatus.ts b/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerStatus.ts new file mode 100644 index 00000000000..83135a580e2 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1HorizontalPodAutoscalerStatus.ts @@ -0,0 +1,59 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V2beta1HorizontalPodAutoscalerCondition } from './V2beta1HorizontalPodAutoscalerCondition'; +import { V2beta1MetricStatus } from './V2beta1MetricStatus'; + +/** + * HorizontalPodAutoscalerStatus describes the current status of a horizontal pod autoscaler. + * @export + * @interface V2beta1HorizontalPodAutoscalerStatus + */ +export interface V2beta1HorizontalPodAutoscalerStatus { + /** + * conditions is the set of conditions required for this autoscaler to scale its target, and indicates whether or not those conditions are met. + * @type {Array} + * @memberof V2beta1HorizontalPodAutoscalerStatus + */ + conditions: V2beta1HorizontalPodAutoscalerCondition[]; + /** + * currentMetrics is the last read state of the metrics used by this autoscaler. + * @type {Array} + * @memberof V2beta1HorizontalPodAutoscalerStatus + */ + currentMetrics: V2beta1MetricStatus[]; + /** + * currentReplicas is current number of replicas of pods managed by this autoscaler, as last seen by the autoscaler. + * @type {number} + * @memberof V2beta1HorizontalPodAutoscalerStatus + */ + currentReplicas: number; + /** + * desiredReplicas is the desired number of replicas of pods managed by this autoscaler, as last calculated by the autoscaler. + * @type {number} + * @memberof V2beta1HorizontalPodAutoscalerStatus + */ + desiredReplicas: number; + /** + * + * @type {string} + * @memberof V2beta1HorizontalPodAutoscalerStatus + */ + lastScaleTime?: string; + /** + * observedGeneration is the most recent generation observed by this autoscaler. + * @type {number} + * @memberof V2beta1HorizontalPodAutoscalerStatus + */ + observedGeneration?: number; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1MetricSpec.ts b/frontend/packages/kube-types/src/openshift/V2beta1MetricSpec.ts new file mode 100644 index 00000000000..275811cff80 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1MetricSpec.ts @@ -0,0 +1,55 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V2beta1ExternalMetricSource } from './V2beta1ExternalMetricSource'; +import { V2beta1ObjectMetricSource } from './V2beta1ObjectMetricSource'; +import { V2beta1PodsMetricSource } from './V2beta1PodsMetricSource'; +import { V2beta1ResourceMetricSource } from './V2beta1ResourceMetricSource'; + +/** + * MetricSpec specifies how to scale based on a single metric (only `type` and one other matching field should be set at once). + * @export + * @interface V2beta1MetricSpec + */ +export interface V2beta1MetricSpec { + /** + * + * @type {V2beta1ExternalMetricSource} + * @memberof V2beta1MetricSpec + */ + external?: V2beta1ExternalMetricSource; + /** + * + * @type {V2beta1ObjectMetricSource} + * @memberof V2beta1MetricSpec + */ + object?: V2beta1ObjectMetricSource; + /** + * + * @type {V2beta1PodsMetricSource} + * @memberof V2beta1MetricSpec + */ + pods?: V2beta1PodsMetricSource; + /** + * + * @type {V2beta1ResourceMetricSource} + * @memberof V2beta1MetricSpec + */ + resource?: V2beta1ResourceMetricSource; + /** + * type is the type of metric source. It should be one of \"Object\", \"Pods\" or \"Resource\", each mapping to a matching field in the object. + * @type {string} + * @memberof V2beta1MetricSpec + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1MetricStatus.ts b/frontend/packages/kube-types/src/openshift/V2beta1MetricStatus.ts new file mode 100644 index 00000000000..994ace7f8e4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1MetricStatus.ts @@ -0,0 +1,55 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V2beta1ExternalMetricStatus } from './V2beta1ExternalMetricStatus'; +import { V2beta1ObjectMetricStatus } from './V2beta1ObjectMetricStatus'; +import { V2beta1PodsMetricStatus } from './V2beta1PodsMetricStatus'; +import { V2beta1ResourceMetricStatus } from './V2beta1ResourceMetricStatus'; + +/** + * MetricStatus describes the last-read state of a single metric. + * @export + * @interface V2beta1MetricStatus + */ +export interface V2beta1MetricStatus { + /** + * + * @type {V2beta1ExternalMetricStatus} + * @memberof V2beta1MetricStatus + */ + external?: V2beta1ExternalMetricStatus; + /** + * + * @type {V2beta1ObjectMetricStatus} + * @memberof V2beta1MetricStatus + */ + object?: V2beta1ObjectMetricStatus; + /** + * + * @type {V2beta1PodsMetricStatus} + * @memberof V2beta1MetricStatus + */ + pods?: V2beta1PodsMetricStatus; + /** + * + * @type {V2beta1ResourceMetricStatus} + * @memberof V2beta1MetricStatus + */ + resource?: V2beta1ResourceMetricStatus; + /** + * type is the type of metric source. It will be one of \"Object\", \"Pods\" or \"Resource\", each corresponds to a matching field in the object. + * @type {string} + * @memberof V2beta1MetricStatus + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1ObjectMetricSource.ts b/frontend/packages/kube-types/src/openshift/V2beta1ObjectMetricSource.ts new file mode 100644 index 00000000000..e5ff8d06ff7 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1ObjectMetricSource.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V2beta1CrossVersionObjectReference } from './V2beta1CrossVersionObjectReference'; + +/** + * ObjectMetricSource indicates how to scale on a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). + * @export + * @interface V2beta1ObjectMetricSource + */ +export interface V2beta1ObjectMetricSource { + /** + * metricName is the name of the metric in question. + * @type {string} + * @memberof V2beta1ObjectMetricSource + */ + metricName: string; + /** + * + * @type {V2beta1CrossVersionObjectReference} + * @memberof V2beta1ObjectMetricSource + */ + target: V2beta1CrossVersionObjectReference; + /** + * + * @type {string} + * @memberof V2beta1ObjectMetricSource + */ + targetValue: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1ObjectMetricStatus.ts b/frontend/packages/kube-types/src/openshift/V2beta1ObjectMetricStatus.ts new file mode 100644 index 00000000000..6dbfa0355d6 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1ObjectMetricStatus.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V2beta1CrossVersionObjectReference } from './V2beta1CrossVersionObjectReference'; + +/** + * ObjectMetricStatus indicates the current value of a metric describing a kubernetes object (for example, hits-per-second on an Ingress object). + * @export + * @interface V2beta1ObjectMetricStatus + */ +export interface V2beta1ObjectMetricStatus { + /** + * + * @type {string} + * @memberof V2beta1ObjectMetricStatus + */ + currentValue: string; + /** + * metricName is the name of the metric in question. + * @type {string} + * @memberof V2beta1ObjectMetricStatus + */ + metricName: string; + /** + * + * @type {V2beta1CrossVersionObjectReference} + * @memberof V2beta1ObjectMetricStatus + */ + target: V2beta1CrossVersionObjectReference; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1PodsMetricSource.ts b/frontend/packages/kube-types/src/openshift/V2beta1PodsMetricSource.ts new file mode 100644 index 00000000000..6e73d9dee98 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1PodsMetricSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PodsMetricSource indicates how to scale on a metric describing each pod in the current scale target (for example, transactions-processed-per-second). The values will be averaged together before being compared to the target value. + * @export + * @interface V2beta1PodsMetricSource + */ +export interface V2beta1PodsMetricSource { + /** + * metricName is the name of the metric in question + * @type {string} + * @memberof V2beta1PodsMetricSource + */ + metricName: string; + /** + * + * @type {string} + * @memberof V2beta1PodsMetricSource + */ + targetAverageValue: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1PodsMetricStatus.ts b/frontend/packages/kube-types/src/openshift/V2beta1PodsMetricStatus.ts new file mode 100644 index 00000000000..a1af1bb2ed4 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1PodsMetricStatus.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PodsMetricStatus indicates the current value of a metric describing each pod in the current scale target (for example, transactions-processed-per-second). + * @export + * @interface V2beta1PodsMetricStatus + */ +export interface V2beta1PodsMetricStatus { + /** + * + * @type {string} + * @memberof V2beta1PodsMetricStatus + */ + currentAverageValue: string; + /** + * metricName is the name of the metric in question + * @type {string} + * @memberof V2beta1PodsMetricStatus + */ + metricName: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1ResourceMetricSource.ts b/frontend/packages/kube-types/src/openshift/V2beta1ResourceMetricSource.ts new file mode 100644 index 00000000000..ec2151cee40 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1ResourceMetricSource.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ResourceMetricSource indicates how to scale on a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). The values will be averaged together before being compared to the target. Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. Only one \"target\" type should be set. + * @export + * @interface V2beta1ResourceMetricSource + */ +export interface V2beta1ResourceMetricSource { + /** + * name is the name of the resource in question. + * @type {string} + * @memberof V2beta1ResourceMetricSource + */ + name: string; + /** + * targetAverageUtilization is the target value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. + * @type {number} + * @memberof V2beta1ResourceMetricSource + */ + targetAverageUtilization?: number; + /** + * + * @type {string} + * @memberof V2beta1ResourceMetricSource + */ + targetAverageValue?: string; +} diff --git a/frontend/packages/kube-types/src/openshift/V2beta1ResourceMetricStatus.ts b/frontend/packages/kube-types/src/openshift/V2beta1ResourceMetricStatus.ts new file mode 100644 index 00000000000..dbd18432a0f --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/V2beta1ResourceMetricStatus.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * OpenShift API (with Kubernetes) + * OpenShift provides builds, application lifecycle, image content management, and administrative policy on top of Kubernetes. The API allows consistent management of those objects. All API operations are authenticated via an Authorization bearer token that is provided for service accounts as a generated secret (in JWT form) or via the native OAuth endpoint located at /oauth/authorize. Core infrastructure components may use client certificates that require no authentication. All API operations return a \'resourceVersion\' string that represents the version of the object in the underlying storage. The standard LIST operation performs a snapshot read of the underlying objects, returning a resourceVersion representing a consistent version of the listed objects. The WATCH operation allows all updates to a set of objects after the provided resourceVersion to be observed by a client. By listing and beginning a watch from the returned resourceVersion, clients may observe a consistent view of the state of one or more objects. Note that WATCH always returns the update after the provided resourceVersion. Watch may be extended a limited time in the past - using etcd 2 the watch window is 1000 events (which on a large cluster may only be a few tens of seconds) so clients must explicitly handle the \"watch to old error\" by re-listing. Objects are divided into two rough categories - those that have a lifecycle and must reflect the state of the cluster, and those that have no state. Objects with lifecycle typically have three main sections: * \'metadata\' common to all objects * a \'spec\' that represents the desired state * a \'status\' that represents how much of the desired state is reflected on the cluster at the current time Objects that have no state have \'metadata\' but may lack a \'spec\' or \'status\' section. Objects are divided into those that are namespace scoped (only exist inside of a namespace) and those that are cluster scoped (exist outside of a namespace). A namespace scoped resource will be deleted when the namespace is deleted and cannot be created if the namespace has not yet been created or is in the process of deletion. Cluster scoped resources are typically only accessible to admins - resources like nodes, persistent volumes, and cluster policy. All objects have a schema that is a combination of the \'kind\' and \'apiVersion\' fields. This schema is additive only for any given version - no backwards incompatible changes are allowed without incrementing the apiVersion. The server will return and accept a number of standard responses that share a common schema - for instance, the common error type is \'metav1.Status\' (described below) and will be returned on any error from the API server. The API is available in multiple serialization formats - the default is JSON (Accept: application/json and Content-Type: application/json) but clients may also use YAML (application/yaml) or the native Protobuf schema (application/vnd.kubernetes.protobuf). Note that the format of the WATCH API call is slightly different - for JSON it returns newline delimited objects while for Protobuf it returns length-delimited frames (4 bytes in network-order) that contain a \'versioned.Watch\' Protobuf object. See the OpenShift documentation at https://docs.openshift.org for more information. + * + * The version of the OpenAPI document: latest + * + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ResourceMetricStatus indicates the current value of a resource metric known to Kubernetes, as specified in requests and limits, describing each pod in the current scale target (e.g. CPU or memory). Such metrics are built in to Kubernetes, and have special scaling options on top of those available to normal per-pod metrics using the \"pods\" source. + * @export + * @interface V2beta1ResourceMetricStatus + */ +export interface V2beta1ResourceMetricStatus { + /** + * currentAverageUtilization is the current value of the average of the resource metric across all relevant pods, represented as a percentage of the requested value of the resource for the pods. It will only be present if `targetAverageValue` was set in the corresponding metric specification. + * @type {number} + * @memberof V2beta1ResourceMetricStatus + */ + currentAverageUtilization?: number; + /** + * + * @type {string} + * @memberof V2beta1ResourceMetricStatus + */ + currentAverageValue: string; + /** + * name is the name of the resource in question. + * @type {string} + * @memberof V2beta1ResourceMetricStatus + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/openshift/index.ts b/frontend/packages/kube-types/src/openshift/index.ts new file mode 100644 index 00000000000..f7a7476d347 --- /dev/null +++ b/frontend/packages/kube-types/src/openshift/index.ts @@ -0,0 +1,691 @@ +export * from './OSV1CustomDeploymentStrategyParams'; +export * from './OSV1DeploymentCause'; +export * from './OSV1DeploymentCauseImageTrigger'; +export * from './OSV1DeploymentCondition'; +export * from './OSV1DeploymentConfig'; +export * from './OSV1DeploymentConfigList'; +export * from './OSV1DeploymentConfigRollback'; +export * from './OSV1DeploymentConfigRollbackSpec'; +export * from './OSV1DeploymentConfigSpec'; +export * from './OSV1DeploymentConfigStatus'; +export * from './OSV1DeploymentDetails'; +export * from './OSV1DeploymentLog'; +export * from './OSV1DeploymentRequest'; +export * from './OSV1DeploymentStrategy'; +export * from './OSV1DeploymentTriggerImageChangeParams'; +export * from './OSV1DeploymentTriggerPolicy'; +export * from './OSV1ExecNewPodHook'; +export * from './OSV1LifecycleHook'; +export * from './OSV1RecreateDeploymentStrategyParams'; +export * from './OSV1RollingDeploymentStrategyParams'; +export * from './OSV1TagImageHook'; +export * from './OSV1ClusterRole'; +export * from './OSV1ClusterRoleBinding'; +export * from './OSV1ClusterRoleBindingList'; +export * from './OSV1ClusterRoleList'; +export * from './OSV1GroupRestriction'; +export * from './OSV1LocalResourceAccessReview'; +export * from './OSV1LocalSubjectAccessReview'; +export * from './OSV1PolicyRule'; +export * from './OSV1ResourceAccessReview'; +export * from './OSV1Role'; +export * from './OSV1RoleBinding'; +export * from './OSV1RoleBindingList'; +export * from './OSV1RoleBindingRestriction'; +export * from './OSV1RoleBindingRestrictionList'; +export * from './OSV1RoleBindingRestrictionSpec'; +export * from './OSV1RoleList'; +export * from './OSV1SelfSubjectRulesReview'; +export * from './OSV1SelfSubjectRulesReviewSpec'; +export * from './OSV1ServiceAccountReference'; +export * from './OSV1ServiceAccountRestriction'; +export * from './OSV1SubjectAccessReview'; +export * from './OSV1SubjectRulesReview'; +export * from './OSV1SubjectRulesReviewSpec'; +export * from './OSV1SubjectRulesReviewStatus'; +export * from './OSV1UserRestriction'; +export * from './OSV1BinaryBuildSource'; +export * from './OSV1BitbucketWebHookCause'; +export * from './OSV1Build'; +export * from './OSV1BuildConfig'; +export * from './OSV1BuildConfigList'; +export * from './OSV1BuildConfigSpec'; +export * from './OSV1BuildConfigStatus'; +export * from './OSV1BuildList'; +export * from './OSV1BuildLog'; +export * from './OSV1BuildOutput'; +export * from './OSV1BuildPostCommitSpec'; +export * from './OSV1BuildRequest'; +export * from './OSV1BuildSource'; +export * from './OSV1BuildSpec'; +export * from './OSV1BuildStatus'; +export * from './OSV1BuildStatusOutput'; +export * from './OSV1BuildStatusOutputTo'; +export * from './OSV1BuildStrategy'; +export * from './OSV1BuildTriggerCause'; +export * from './OSV1BuildTriggerPolicy'; +export * from './OSV1ConfigMapBuildSource'; +export * from './OSV1CustomBuildStrategy'; +export * from './OSV1DockerBuildStrategy'; +export * from './OSV1DockerStrategyOptions'; +export * from './OSV1GenericWebHookCause'; +export * from './OSV1GitBuildSource'; +export * from './OSV1GitHubWebHookCause'; +export * from './OSV1GitLabWebHookCause'; +export * from './OSV1GitSourceRevision'; +export * from './OSV1ImageChangeCause'; +export * from './OSV1ImageChangeTrigger'; +export * from './OSV1ImageLabel'; +export * from './OSV1ImageSource'; +export * from './OSV1ImageSourcePath'; +export * from './OSV1JenkinsPipelineBuildStrategy'; +export * from './OSV1SecretBuildSource'; +export * from './OSV1SecretLocalReference'; +export * from './OSV1SecretSpec'; +export * from './OSV1SourceBuildStrategy'; +export * from './OSV1SourceControlUser'; +export * from './OSV1SourceRevision'; +export * from './OSV1SourceStrategyOptions'; +export * from './OSV1StageInfo'; +export * from './OSV1StepInfo'; +export * from './OSV1WebHookTrigger'; +export * from './OSV1Image'; +export * from './OSV1ImageBlobReferences'; +export * from './OSV1ImageImportSpec'; +export * from './OSV1ImageImportStatus'; +export * from './OSV1ImageLayer'; +export * from './OSV1ImageLayerData'; +export * from './OSV1ImageList'; +export * from './OSV1ImageLookupPolicy'; +export * from './OSV1ImageSignature'; +export * from './OSV1ImageStream'; +export * from './OSV1ImageStreamImage'; +export * from './OSV1ImageStreamImport'; +export * from './OSV1ImageStreamImportSpec'; +export * from './OSV1ImageStreamImportStatus'; +export * from './OSV1ImageStreamLayers'; +export * from './OSV1ImageStreamList'; +export * from './OSV1ImageStreamMapping'; +export * from './OSV1ImageStreamSpec'; +export * from './OSV1ImageStreamStatus'; +export * from './OSV1ImageStreamTag'; +export * from './OSV1ImageStreamTagList'; +export * from './OSV1NamedTagEventList'; +export * from './OSV1RepositoryImportSpec'; +export * from './OSV1RepositoryImportStatus'; +export * from './OSV1SignatureCondition'; +export * from './OSV1SignatureIssuer'; +export * from './OSV1SignatureSubject'; +export * from './OSV1TagEvent'; +export * from './OSV1TagEventCondition'; +export * from './OSV1TagImportPolicy'; +export * from './OSV1TagReference'; +export * from './OSV1TagReferencePolicy'; +export * from './OSV1ClusterNetwork'; +export * from './OSV1ClusterNetworkEntry'; +export * from './OSV1ClusterNetworkList'; +export * from './OSV1EgressNetworkPolicy'; +export * from './OSV1EgressNetworkPolicyList'; +export * from './OSV1EgressNetworkPolicyPeer'; +export * from './OSV1EgressNetworkPolicyRule'; +export * from './OSV1EgressNetworkPolicySpec'; +export * from './OSV1HostSubnet'; +export * from './OSV1HostSubnetList'; +export * from './OSV1NetNamespace'; +export * from './OSV1NetNamespaceList'; +export * from './OSV1ClusterRoleScopeRestriction'; +export * from './OSV1OAuthAccessToken'; +export * from './OSV1OAuthAccessTokenList'; +export * from './OSV1OAuthAuthorizeToken'; +export * from './OSV1OAuthAuthorizeTokenList'; +export * from './OSV1OAuthClient'; +export * from './OSV1OAuthClientAuthorization'; +export * from './OSV1OAuthClientAuthorizationList'; +export * from './OSV1OAuthClientList'; +export * from './OSV1ScopeRestriction'; +export * from './V1Project'; +export * from './V1ProjectList'; +export * from './V1ProjectRequest'; +export * from './V1ProjectSpec'; +export * from './V1ProjectStatus'; +export * from './OSV1AppliedClusterResourceQuota'; +export * from './OSV1AppliedClusterResourceQuotaList'; +export * from './OSV1ClusterResourceQuota'; +export * from './OSV1ClusterResourceQuotaList'; +export * from './OSV1ClusterResourceQuotaSelector'; +export * from './OSV1ClusterResourceQuotaSpec'; +export * from './OSV1ClusterResourceQuotaStatus'; +export * from './OSV1ResourceQuotaStatusByNamespace'; +export * from './V1Route'; +export * from './V1RouteIngress'; +export * from './V1RouteIngressCondition'; +export * from './V1RouteList'; +export * from './V1RoutePort'; +export * from './V1RouteSpec'; +export * from './V1RouteStatus'; +export * from './V1RouteTargetReference'; +export * from './V1TLSConfig'; +export * from './OSV1AllowedFlexVolume'; +export * from './OSV1FSGroupStrategyOptions'; +export * from './OSV1IDRange'; +export * from './OSV1PodSecurityPolicyReview'; +export * from './OSV1PodSecurityPolicyReviewSpec'; +export * from './OSV1PodSecurityPolicyReviewStatus'; +export * from './OSV1PodSecurityPolicySelfSubjectReview'; +export * from './OSV1PodSecurityPolicySelfSubjectReviewSpec'; +export * from './OSV1PodSecurityPolicySubjectReview'; +export * from './OSV1PodSecurityPolicySubjectReviewSpec'; +export * from './OSV1PodSecurityPolicySubjectReviewStatus'; +export * from './OSV1RangeAllocation'; +export * from './OSV1RangeAllocationList'; +export * from './OSV1RunAsUserStrategyOptions'; +export * from './OSV1SELinuxContextStrategyOptions'; +export * from './OSV1SecurityContextConstraints'; +export * from './OSV1SecurityContextConstraintsList'; +export * from './OSV1ServiceAccountPodSecurityPolicyReviewStatus'; +export * from './OSV1SupplementalGroupsStrategyOptions'; +export * from './V1BrokerTemplateInstance'; +export * from './V1BrokerTemplateInstanceList'; +export * from './V1BrokerTemplateInstanceSpec'; +export * from './V1Parameter'; +export * from './V1Template'; +export * from './V1TemplateInstance'; +export * from './V1TemplateInstanceCondition'; +export * from './V1TemplateInstanceList'; +export * from './V1TemplateInstanceObject'; +export * from './V1TemplateInstanceRequester'; +export * from './V1TemplateInstanceSpec'; +export * from './V1TemplateInstanceStatus'; +export * from './V1TemplateList'; +export * from './OSV1Group'; +export * from './OSV1GroupList'; +export * from './OSV1Identity'; +export * from './OSV1IdentityList'; +export * from './OSV1User'; +export * from './OSV1UserIdentityMapping'; +export * from './OSV1UserList'; +export * from './V1beta1MutatingWebhookConfiguration'; +export * from './V1beta1MutatingWebhookConfigurationList'; +export * from './V1beta1RuleWithOperations'; +export * from './V1beta1ServiceReference'; +export * from './V1beta1ValidatingWebhookConfiguration'; +export * from './V1beta1ValidatingWebhookConfigurationList'; +export * from './V1beta1Webhook'; +export * from './V1beta1WebhookClientConfig'; +export * from './V1ControllerRevision'; +export * from './V1ControllerRevisionList'; +export * from './V1DaemonSet'; +export * from './V1DaemonSetCondition'; +export * from './V1DaemonSetList'; +export * from './V1DaemonSetSpec'; +export * from './V1DaemonSetStatus'; +export * from './V1DaemonSetUpdateStrategy'; +export * from './V1Deployment'; +export * from './V1DeploymentCondition'; +export * from './V1DeploymentList'; +export * from './V1DeploymentSpec'; +export * from './V1DeploymentStatus'; +export * from './V1DeploymentStrategy'; +export * from './V1ReplicaSet'; +export * from './V1ReplicaSetCondition'; +export * from './V1ReplicaSetList'; +export * from './V1ReplicaSetSpec'; +export * from './V1ReplicaSetStatus'; +export * from './V1RollingUpdateDaemonSet'; +export * from './V1RollingUpdateDeployment'; +export * from './V1RollingUpdateStatefulSetStrategy'; +export * from './V1StatefulSet'; +export * from './V1StatefulSetCondition'; +export * from './V1StatefulSetList'; +export * from './V1StatefulSetSpec'; +export * from './V1StatefulSetStatus'; +export * from './V1StatefulSetUpdateStrategy'; +export * from './V1beta1ControllerRevision'; +export * from './V1beta1ControllerRevisionList'; +export * from './V1beta1Deployment'; +export * from './V1beta1DeploymentCondition'; +export * from './V1beta1DeploymentList'; +export * from './V1beta1DeploymentRollback'; +export * from './V1beta1DeploymentSpec'; +export * from './V1beta1DeploymentStatus'; +export * from './V1beta1DeploymentStrategy'; +export * from './V1beta1RollbackConfig'; +export * from './V1beta1RollingUpdateDeployment'; +export * from './V1beta1RollingUpdateStatefulSetStrategy'; +export * from './V1beta1Scale'; +export * from './V1beta1ScaleSpec'; +export * from './V1beta1ScaleStatus'; +export * from './V1beta1StatefulSet'; +export * from './V1beta1StatefulSetCondition'; +export * from './V1beta1StatefulSetList'; +export * from './V1beta1StatefulSetSpec'; +export * from './V1beta1StatefulSetStatus'; +export * from './V1beta1StatefulSetUpdateStrategy'; +export * from './V1beta2ControllerRevision'; +export * from './V1beta2ControllerRevisionList'; +export * from './V1beta2DaemonSet'; +export * from './V1beta2DaemonSetCondition'; +export * from './V1beta2DaemonSetList'; +export * from './V1beta2DaemonSetSpec'; +export * from './V1beta2DaemonSetStatus'; +export * from './V1beta2DaemonSetUpdateStrategy'; +export * from './V1beta2Deployment'; +export * from './V1beta2DeploymentCondition'; +export * from './V1beta2DeploymentList'; +export * from './V1beta2DeploymentSpec'; +export * from './V1beta2DeploymentStatus'; +export * from './V1beta2DeploymentStrategy'; +export * from './V1beta2ReplicaSet'; +export * from './V1beta2ReplicaSetCondition'; +export * from './V1beta2ReplicaSetList'; +export * from './V1beta2ReplicaSetSpec'; +export * from './V1beta2ReplicaSetStatus'; +export * from './V1beta2RollingUpdateDaemonSet'; +export * from './V1beta2RollingUpdateDeployment'; +export * from './V1beta2RollingUpdateStatefulSetStrategy'; +export * from './V1beta2Scale'; +export * from './V1beta2ScaleSpec'; +export * from './V1beta2ScaleStatus'; +export * from './V1beta2StatefulSet'; +export * from './V1beta2StatefulSetCondition'; +export * from './V1beta2StatefulSetList'; +export * from './V1beta2StatefulSetSpec'; +export * from './V1beta2StatefulSetStatus'; +export * from './V1beta2StatefulSetUpdateStrategy'; +export * from './V1TokenReview'; +export * from './V1TokenReviewSpec'; +export * from './V1TokenReviewStatus'; +export * from './V1UserInfo'; +export * from './V1beta1TokenReview'; +export * from './V1beta1TokenReviewSpec'; +export * from './V1beta1TokenReviewStatus'; +export * from './V1beta1UserInfo'; +export * from './V1LocalSubjectAccessReview'; +export * from './V1NonResourceAttributes'; +export * from './V1NonResourceRule'; +export * from './V1ResourceAttributes'; +export * from './V1ResourceRule'; +export * from './V1SelfSubjectAccessReview'; +export * from './V1SelfSubjectAccessReviewSpec'; +export * from './V1SelfSubjectRulesReview'; +export * from './V1SelfSubjectRulesReviewSpec'; +export * from './V1SubjectAccessReview'; +export * from './V1SubjectAccessReviewSpec'; +export * from './V1SubjectAccessReviewStatus'; +export * from './V1SubjectRulesReviewStatus'; +export * from './V1beta1LocalSubjectAccessReview'; +export * from './V1beta1NonResourceAttributes'; +export * from './V1beta1NonResourceRule'; +export * from './V1beta1ResourceAttributes'; +export * from './V1beta1ResourceRule'; +export * from './V1beta1SelfSubjectAccessReview'; +export * from './V1beta1SelfSubjectAccessReviewSpec'; +export * from './V1beta1SelfSubjectRulesReview'; +export * from './V1beta1SelfSubjectRulesReviewSpec'; +export * from './V1beta1SubjectAccessReview'; +export * from './V1beta1SubjectAccessReviewSpec'; +export * from './V1beta1SubjectAccessReviewStatus'; +export * from './V1beta1SubjectRulesReviewStatus'; +export * from './V1CrossVersionObjectReference'; +export * from './V1HorizontalPodAutoscaler'; +export * from './V1HorizontalPodAutoscalerList'; +export * from './V1HorizontalPodAutoscalerSpec'; +export * from './V1HorizontalPodAutoscalerStatus'; +export * from './V1Scale'; +export * from './V1ScaleSpec'; +export * from './V1ScaleStatus'; +export * from './V2beta1CrossVersionObjectReference'; +export * from './V2beta1ExternalMetricSource'; +export * from './V2beta1ExternalMetricStatus'; +export * from './V2beta1HorizontalPodAutoscaler'; +export * from './V2beta1HorizontalPodAutoscalerCondition'; +export * from './V2beta1HorizontalPodAutoscalerList'; +export * from './V2beta1HorizontalPodAutoscalerSpec'; +export * from './V2beta1HorizontalPodAutoscalerStatus'; +export * from './V2beta1MetricSpec'; +export * from './V2beta1MetricStatus'; +export * from './V2beta1ObjectMetricSource'; +export * from './V2beta1ObjectMetricStatus'; +export * from './V2beta1PodsMetricSource'; +export * from './V2beta1PodsMetricStatus'; +export * from './V2beta1ResourceMetricSource'; +export * from './V2beta1ResourceMetricStatus'; +export * from './V1Job'; +export * from './V1JobCondition'; +export * from './V1JobList'; +export * from './V1JobSpec'; +export * from './V1JobStatus'; +export * from './V1beta1CronJob'; +export * from './V1beta1CronJobList'; +export * from './V1beta1CronJobSpec'; +export * from './V1beta1CronJobStatus'; +export * from './V1beta1JobTemplateSpec'; +export * from './V1beta1CertificateSigningRequest'; +export * from './V1beta1CertificateSigningRequestCondition'; +export * from './V1beta1CertificateSigningRequestList'; +export * from './V1beta1CertificateSigningRequestSpec'; +export * from './V1beta1CertificateSigningRequestStatus'; +export * from './V1AWSElasticBlockStoreVolumeSource'; +export * from './V1Affinity'; +export * from './V1AttachedVolume'; +export * from './V1AzureDiskVolumeSource'; +export * from './V1AzureFilePersistentVolumeSource'; +export * from './V1AzureFileVolumeSource'; +export * from './V1Binding'; +export * from './V1CSIPersistentVolumeSource'; +export * from './V1Capabilities'; +export * from './V1CephFSPersistentVolumeSource'; +export * from './V1CephFSVolumeSource'; +export * from './V1CinderPersistentVolumeSource'; +export * from './V1CinderVolumeSource'; +export * from './V1ClientIPConfig'; +export * from './V1ComponentCondition'; +export * from './V1ComponentStatus'; +export * from './V1ComponentStatusList'; +export * from './V1ConfigMap'; +export * from './V1ConfigMapEnvSource'; +export * from './V1ConfigMapKeySelector'; +export * from './V1ConfigMapList'; +export * from './V1ConfigMapNodeConfigSource'; +export * from './V1ConfigMapProjection'; +export * from './V1ConfigMapVolumeSource'; +export * from './V1Container'; +export * from './V1ContainerImage'; +export * from './V1ContainerPort'; +export * from './V1ContainerState'; +export * from './V1ContainerStateRunning'; +export * from './V1ContainerStateTerminated'; +export * from './V1ContainerStateWaiting'; +export * from './V1ContainerStatus'; +export * from './V1DaemonEndpoint'; +export * from './V1DownwardAPIProjection'; +export * from './V1DownwardAPIVolumeFile'; +export * from './V1DownwardAPIVolumeSource'; +export * from './V1EmptyDirVolumeSource'; +export * from './V1EndpointAddress'; +export * from './V1EndpointPort'; +export * from './V1EndpointSubset'; +export * from './V1Endpoints'; +export * from './V1EndpointsList'; +export * from './V1EnvFromSource'; +export * from './V1EnvVar'; +export * from './V1EnvVarSource'; +export * from './V1Event'; +export * from './V1EventList'; +export * from './V1EventSeries'; +export * from './V1EventSource'; +export * from './V1ExecAction'; +export * from './V1FCVolumeSource'; +export * from './V1FlexPersistentVolumeSource'; +export * from './V1FlexVolumeSource'; +export * from './V1FlockerVolumeSource'; +export * from './V1GCEPersistentDiskVolumeSource'; +export * from './V1GitRepoVolumeSource'; +export * from './V1GlusterfsVolumeSource'; +export * from './V1HTTPGetAction'; +export * from './V1HTTPHeader'; +export * from './V1Handler'; +export * from './V1HostAlias'; +export * from './V1HostPathVolumeSource'; +export * from './V1ISCSIPersistentVolumeSource'; +export * from './V1ISCSIVolumeSource'; +export * from './V1KeyToPath'; +export * from './V1Lifecycle'; +export * from './V1LimitRange'; +export * from './V1LimitRangeItem'; +export * from './V1LimitRangeList'; +export * from './V1LimitRangeSpec'; +export * from './V1LoadBalancerIngress'; +export * from './V1LoadBalancerStatus'; +export * from './V1LocalObjectReference'; +export * from './V1LocalVolumeSource'; +export * from './V1NFSVolumeSource'; +export * from './V1Namespace'; +export * from './V1NamespaceList'; +export * from './V1NamespaceSpec'; +export * from './V1NamespaceStatus'; +export * from './V1Node'; +export * from './V1NodeAddress'; +export * from './V1NodeAffinity'; +export * from './V1NodeCondition'; +export * from './V1NodeConfigSource'; +export * from './V1NodeConfigStatus'; +export * from './V1NodeDaemonEndpoints'; +export * from './V1NodeList'; +export * from './V1NodeSelector'; +export * from './V1NodeSelectorRequirement'; +export * from './V1NodeSelectorTerm'; +export * from './V1NodeSpec'; +export * from './V1NodeStatus'; +export * from './V1NodeSystemInfo'; +export * from './V1ObjectFieldSelector'; +export * from './V1ObjectReference'; +export * from './V1PersistentVolume'; +export * from './V1PersistentVolumeClaim'; +export * from './V1PersistentVolumeClaimCondition'; +export * from './V1PersistentVolumeClaimList'; +export * from './V1PersistentVolumeClaimSpec'; +export * from './V1PersistentVolumeClaimStatus'; +export * from './V1PersistentVolumeClaimVolumeSource'; +export * from './V1PersistentVolumeList'; +export * from './V1PersistentVolumeSpec'; +export * from './V1PersistentVolumeStatus'; +export * from './V1PhotonPersistentDiskVolumeSource'; +export * from './V1Pod'; +export * from './V1PodAffinity'; +export * from './V1PodAffinityTerm'; +export * from './V1PodAntiAffinity'; +export * from './V1PodCondition'; +export * from './V1PodDNSConfig'; +export * from './V1PodDNSConfigOption'; +export * from './V1PodList'; +export * from './V1PodReadinessGate'; +export * from './V1PodSecurityContext'; +export * from './V1PodSpec'; +export * from './V1PodStatus'; +export * from './V1PodTemplate'; +export * from './V1PodTemplateList'; +export * from './V1PodTemplateSpec'; +export * from './V1PortworxVolumeSource'; +export * from './V1PreferredSchedulingTerm'; +export * from './V1Probe'; +export * from './V1ProjectedVolumeSource'; +export * from './V1QuobyteVolumeSource'; +export * from './V1RBDPersistentVolumeSource'; +export * from './V1RBDVolumeSource'; +export * from './V1ReplicationController'; +export * from './V1ReplicationControllerCondition'; +export * from './V1ReplicationControllerList'; +export * from './V1ReplicationControllerSpec'; +export * from './V1ReplicationControllerStatus'; +export * from './V1ResourceFieldSelector'; +export * from './V1ResourceQuota'; +export * from './V1ResourceQuotaList'; +export * from './V1ResourceQuotaSpec'; +export * from './V1ResourceQuotaStatus'; +export * from './V1ResourceRequirements'; +export * from './V1SELinuxOptions'; +export * from './V1ScaleIOPersistentVolumeSource'; +export * from './V1ScaleIOVolumeSource'; +export * from './V1ScopeSelector'; +export * from './V1ScopedResourceSelectorRequirement'; +export * from './V1Secret'; +export * from './V1SecretEnvSource'; +export * from './V1SecretKeySelector'; +export * from './V1SecretList'; +export * from './V1SecretProjection'; +export * from './V1SecretReference'; +export * from './V1SecretVolumeSource'; +export * from './V1SecurityContext'; +export * from './V1Service'; +export * from './V1ServiceAccount'; +export * from './V1ServiceAccountList'; +export * from './V1ServiceAccountTokenProjection'; +export * from './V1ServiceList'; +export * from './V1ServicePort'; +export * from './V1ServiceSpec'; +export * from './V1ServiceStatus'; +export * from './V1SessionAffinityConfig'; +export * from './V1StorageOSPersistentVolumeSource'; +export * from './V1StorageOSVolumeSource'; +export * from './V1Sysctl'; +export * from './V1TCPSocketAction'; +export * from './V1Taint'; +export * from './V1Toleration'; +export * from './V1TopologySelectorLabelRequirement'; +export * from './V1TopologySelectorTerm'; +export * from './V1Volume'; +export * from './V1VolumeDevice'; +export * from './V1VolumeMount'; +export * from './V1VolumeNodeAffinity'; +export * from './V1VolumeProjection'; +export * from './V1VsphereVirtualDiskVolumeSource'; +export * from './V1WeightedPodAffinityTerm'; +export * from './V1beta1Event'; +export * from './V1beta1EventList'; +export * from './V1beta1EventSeries'; +export * from './ExtensionsV1beta1AllowedFlexVolume'; +export * from './ExtensionsV1beta1AllowedHostPath'; +export * from './ExtensionsV1beta1DaemonSet'; +export * from './ExtensionsV1beta1DaemonSetCondition'; +export * from './ExtensionsV1beta1DaemonSetList'; +export * from './ExtensionsV1beta1DaemonSetSpec'; +export * from './ExtensionsV1beta1DaemonSetStatus'; +export * from './ExtensionsV1beta1DaemonSetUpdateStrategy'; +export * from './ExtensionsV1beta1Deployment'; +export * from './ExtensionsV1beta1DeploymentCondition'; +export * from './ExtensionsV1beta1DeploymentList'; +export * from './ExtensionsV1beta1DeploymentRollback'; +export * from './ExtensionsV1beta1DeploymentSpec'; +export * from './ExtensionsV1beta1DeploymentStatus'; +export * from './ExtensionsV1beta1DeploymentStrategy'; +export * from './ExtensionsV1beta1FSGroupStrategyOptions'; +export * from './ExtensionsV1beta1HTTPIngressPath'; +export * from './ExtensionsV1beta1HTTPIngressRuleValue'; +export * from './ExtensionsV1beta1HostPortRange'; +export * from './ExtensionsV1beta1IDRange'; +export * from './ExtensionsV1beta1IPBlock'; +export * from './ExtensionsV1beta1Ingress'; +export * from './ExtensionsV1beta1IngressBackend'; +export * from './ExtensionsV1beta1IngressList'; +export * from './ExtensionsV1beta1IngressRule'; +export * from './ExtensionsV1beta1IngressSpec'; +export * from './ExtensionsV1beta1IngressStatus'; +export * from './ExtensionsV1beta1IngressTLS'; +export * from './ExtensionsV1beta1NetworkPolicy'; +export * from './ExtensionsV1beta1NetworkPolicyEgressRule'; +export * from './ExtensionsV1beta1NetworkPolicyIngressRule'; +export * from './ExtensionsV1beta1NetworkPolicyList'; +export * from './ExtensionsV1beta1NetworkPolicyPeer'; +export * from './ExtensionsV1beta1NetworkPolicyPort'; +export * from './ExtensionsV1beta1NetworkPolicySpec'; +export * from './ExtensionsV1beta1PodSecurityPolicy'; +export * from './ExtensionsV1beta1PodSecurityPolicyList'; +export * from './ExtensionsV1beta1PodSecurityPolicySpec'; +export * from './ExtensionsV1beta1ReplicaSet'; +export * from './ExtensionsV1beta1ReplicaSetCondition'; +export * from './ExtensionsV1beta1ReplicaSetList'; +export * from './ExtensionsV1beta1ReplicaSetSpec'; +export * from './ExtensionsV1beta1ReplicaSetStatus'; +export * from './ExtensionsV1beta1RollbackConfig'; +export * from './ExtensionsV1beta1RollingUpdateDaemonSet'; +export * from './ExtensionsV1beta1RollingUpdateDeployment'; +export * from './ExtensionsV1beta1RunAsUserStrategyOptions'; +export * from './ExtensionsV1beta1SELinuxStrategyOptions'; +export * from './ExtensionsV1beta1Scale'; +export * from './ExtensionsV1beta1ScaleSpec'; +export * from './ExtensionsV1beta1ScaleStatus'; +export * from './ExtensionsV1beta1SupplementalGroupsStrategyOptions'; +export * from './V1IPBlock'; +export * from './V1NetworkPolicy'; +export * from './V1NetworkPolicyEgressRule'; +export * from './V1NetworkPolicyIngressRule'; +export * from './V1NetworkPolicyList'; +export * from './V1NetworkPolicyPeer'; +export * from './V1NetworkPolicyPort'; +export * from './V1NetworkPolicySpec'; +export * from './V1beta1AllowedFlexVolume'; +export * from './V1beta1AllowedHostPath'; +export * from './V1beta1Eviction'; +export * from './V1beta1FSGroupStrategyOptions'; +export * from './V1beta1HostPortRange'; +export * from './V1beta1IDRange'; +export * from './V1beta1PodDisruptionBudget'; +export * from './V1beta1PodDisruptionBudgetList'; +export * from './V1beta1PodDisruptionBudgetSpec'; +export * from './V1beta1PodDisruptionBudgetStatus'; +export * from './V1beta1PodSecurityPolicy'; +export * from './V1beta1PodSecurityPolicyList'; +export * from './V1beta1PodSecurityPolicySpec'; +export * from './V1beta1RunAsUserStrategyOptions'; +export * from './V1beta1SELinuxStrategyOptions'; +export * from './V1beta1SupplementalGroupsStrategyOptions'; +export * from './V1AggregationRule'; +export * from './V1ClusterRole'; +export * from './V1ClusterRoleBinding'; +export * from './V1ClusterRoleBindingList'; +export * from './V1ClusterRoleList'; +export * from './V1PolicyRule'; +export * from './V1Role'; +export * from './V1RoleBinding'; +export * from './V1RoleBindingList'; +export * from './V1RoleList'; +export * from './V1RoleRef'; +export * from './V1Subject'; +export * from './V1beta1AggregationRule'; +export * from './V1beta1ClusterRole'; +export * from './V1beta1ClusterRoleBinding'; +export * from './V1beta1ClusterRoleBindingList'; +export * from './V1beta1ClusterRoleList'; +export * from './V1beta1PolicyRule'; +export * from './V1beta1Role'; +export * from './V1beta1RoleBinding'; +export * from './V1beta1RoleBindingList'; +export * from './V1beta1RoleList'; +export * from './V1beta1RoleRef'; +export * from './V1beta1Subject'; +export * from './V1beta1PriorityClass'; +export * from './V1beta1PriorityClassList'; +export * from './V1StorageClass'; +export * from './V1StorageClassList'; +export * from './V1beta1StorageClass'; +export * from './V1beta1StorageClassList'; +export * from './V1beta1VolumeAttachment'; +export * from './V1beta1VolumeAttachmentList'; +export * from './V1beta1VolumeAttachmentSource'; +export * from './V1beta1VolumeAttachmentSpec'; +export * from './V1beta1VolumeAttachmentStatus'; +export * from './V1beta1VolumeError'; +export * from './V1APIGroup'; +export * from './V1APIGroupList'; +export * from './V1APIResource'; +export * from './V1APIResourceList'; +export * from './V1APIVersions'; +export * from './V1DeleteOptions'; +export * from './V1GroupVersionForDiscovery'; +export * from './V1Initializer'; +export * from './V1Initializers'; +export * from './V1LabelSelector'; +export * from './V1LabelSelectorRequirement'; +export * from './V1ListMeta'; +export * from './V1ObjectMeta'; +export * from './V1OwnerReference'; +export * from './V1Preconditions'; +export * from './V1ServerAddressByClientCIDR'; +export * from './V1Status'; +export * from './V1StatusCause'; +export * from './V1StatusDetails'; +export * from './V1WatchEvent'; +export * from './IoK8sApimachineryPkgRuntimeRawExtension'; +export * from './APIRegistrationV1APIService'; +export * from './APIRegistrationV1APIServiceCondition'; +export * from './APIRegistrationV1APIServiceList'; +export * from './APIRegistrationV1APIServiceSpec'; +export * from './APIRegistrationV1APIServiceStatus'; +export * from './APIRegistrationV1ServiceReference'; +export * from './APIRegistrationV1beta1APIService'; +export * from './APIRegistrationV1beta1APIServiceCondition'; +export * from './APIRegistrationV1beta1APIServiceList'; +export * from './APIRegistrationV1beta1APIServiceSpec'; +export * from './APIRegistrationV1beta1APIServiceStatus'; +export * from './APIRegistrationV1beta1ServiceReference'; From edc9f92e82afb8f7aa841d39fa927d248dfd374e Mon Sep 17 00:00:00 2001 From: suomiy Date: Tue, 25 Jun 2019 17:03:15 +0200 Subject: [PATCH 3/3] kube-types: generate KubeVirt types (v0.17.4) --- .../kube-types/src/kubevirt/V1APIGroup.ts | 59 ++++++++ .../kube-types/src/kubevirt/V1APIGroupList.ts | 40 ++++++ .../kube-types/src/kubevirt/V1APIResource.ts | 74 ++++++++++ .../src/kubevirt/V1APIResourceList.ts | 46 +++++++ .../kube-types/src/kubevirt/V1Affinity.ts | 42 ++++++ .../kube-types/src/kubevirt/V1Bootloader.ts | 32 +++++ .../kube-types/src/kubevirt/V1CDRomTarget.ts | 38 ++++++ .../packages/kube-types/src/kubevirt/V1CPU.ts | 58 ++++++++ .../kube-types/src/kubevirt/V1CPUFeature.ts | 32 +++++ .../kube-types/src/kubevirt/V1Clock.ts | 41 ++++++ .../src/kubevirt/V1ClockOffsetUTC.ts | 26 ++++ .../kubevirt/V1CloudInitConfigDriveSource.ts | 58 ++++++++ .../src/kubevirt/V1CloudInitNoCloudSource.ts | 58 ++++++++ .../src/kubevirt/V1ConfigMapVolumeSource.ts | 32 +++++ .../src/kubevirt/V1ContainerDiskSource.ts | 44 ++++++ .../kube-types/src/kubevirt/V1DHCPOptions.ts | 46 +++++++ .../src/kubevirt/V1DHCPPrivateOptions.ts | 32 +++++ .../src/kubevirt/V1DataVolumeSource.ts | 26 ++++ .../src/kubevirt/V1DeleteOptions.ts | 64 +++++++++ .../kube-types/src/kubevirt/V1Devices.ts | 79 +++++++++++ .../kube-types/src/kubevirt/V1Disk.ts | 79 +++++++++++ .../kube-types/src/kubevirt/V1DiskTarget.ts | 38 ++++++ .../kube-types/src/kubevirt/V1DomainSpec.ts | 83 ++++++++++++ .../src/kubevirt/V1EmptyDiskSource.ts | 26 ++++ .../src/kubevirt/V1EphemeralVolumeSource.ts | 28 ++++ .../kube-types/src/kubevirt/V1FeatureAPIC.ts | 32 +++++ .../src/kubevirt/V1FeatureHyperv.ts | 108 +++++++++++++++ .../src/kubevirt/V1FeatureSpinlocks.ts | 32 +++++ .../kube-types/src/kubevirt/V1FeatureState.ts | 26 ++++ .../src/kubevirt/V1FeatureVendorID.ts | 32 +++++ .../kube-types/src/kubevirt/V1Features.ts | 48 +++++++ .../kube-types/src/kubevirt/V1Firmware.ts | 40 ++++++ .../kube-types/src/kubevirt/V1FloppyTarget.ts | 32 +++++ .../kube-types/src/kubevirt/V1GenieNetwork.ts | 26 ++++ .../kubevirt/V1GroupVersionForDiscovery.ts | 32 +++++ .../kube-types/src/kubevirt/V1HPETTimer.ts | 32 +++++ .../src/kubevirt/V1HTTPGetAction.ts | 46 +++++++ .../kube-types/src/kubevirt/V1HTTPHeader.ts | 32 +++++ .../kube-types/src/kubevirt/V1HostDisk.ts | 44 ++++++ .../kube-types/src/kubevirt/V1Hugepages.ts | 26 ++++ .../kube-types/src/kubevirt/V1HypervTimer.ts | 26 ++++ .../src/kubevirt/V1I6300ESBWatchdog.ts | 26 ++++ .../kube-types/src/kubevirt/V1Initializer.ts | 26 ++++ .../kube-types/src/kubevirt/V1Initializers.ts | 35 +++++ .../kube-types/src/kubevirt/V1Input.ts | 38 ++++++ .../kube-types/src/kubevirt/V1Interface.ts | 89 ++++++++++++ .../kube-types/src/kubevirt/V1KVMTimer.ts | 26 ++++ .../src/kubevirt/V1LabelSelector.ts | 34 +++++ .../kubevirt/V1LabelSelectorRequirement.ts | 38 ++++++ .../kube-types/src/kubevirt/V1ListMeta.ts | 38 ++++++ .../src/kubevirt/V1LocalObjectReference.ts | 26 ++++ .../kube-types/src/kubevirt/V1LunTarget.ts | 32 +++++ .../kube-types/src/kubevirt/V1Machine.ts | 26 ++++ .../kube-types/src/kubevirt/V1Memory.ts | 34 +++++ .../src/kubevirt/V1MultusNetwork.ts | 32 +++++ .../kube-types/src/kubevirt/V1Network.ts | 48 +++++++ .../kube-types/src/kubevirt/V1NodeAffinity.ts | 35 +++++ .../kube-types/src/kubevirt/V1NodeSelector.ts | 28 ++++ .../src/kubevirt/V1NodeSelectorRequirement.ts | 38 ++++++ .../src/kubevirt/V1NodeSelectorTerm.ts | 34 +++++ .../kube-types/src/kubevirt/V1ObjectMeta.ts | 113 ++++++++++++++++ .../src/kubevirt/V1OwnerReference.ts | 56 ++++++++ .../kube-types/src/kubevirt/V1PITTimer.ts | 32 +++++ .../kubevirt/V1PersistentVolumeClaimSpec.ts | 66 +++++++++ .../V1PersistentVolumeClaimVolumeSource.ts | 32 +++++ .../kube-types/src/kubevirt/V1PodAffinity.ts | 35 +++++ .../src/kubevirt/V1PodAffinityTerm.ts | 40 ++++++ .../src/kubevirt/V1PodAntiAffinity.ts | 35 +++++ .../kube-types/src/kubevirt/V1PodDNSConfig.ts | 40 ++++++ .../src/kubevirt/V1PodDNSConfigOption.ts | 32 +++++ .../kube-types/src/kubevirt/V1PodNetwork.ts | 26 ++++ .../kube-types/src/kubevirt/V1Port.ts | 38 ++++++ .../src/kubevirt/V1Preconditions.ts | 26 ++++ .../src/kubevirt/V1PreferredSchedulingTerm.ts | 34 +++++ .../kube-types/src/kubevirt/V1Probe.ts | 65 +++++++++ .../kube-types/src/kubevirt/V1RTCTimer.ts | 38 ++++++ .../src/kubevirt/V1ResourceRequirements.ts | 38 ++++++ .../kube-types/src/kubevirt/V1RootPaths.ts | 26 ++++ .../src/kubevirt/V1SecretVolumeSource.ts | 32 +++++ .../kubevirt/V1ServerAddressByClientCIDR.ts | 32 +++++ .../kubevirt/V1ServiceAccountVolumeSource.ts | 26 ++++ .../kube-types/src/kubevirt/V1Status.ts | 71 ++++++++++ .../kube-types/src/kubevirt/V1StatusCause.ts | 38 ++++++ .../src/kubevirt/V1StatusDetails.ts | 58 ++++++++ .../src/kubevirt/V1TCPSocketAction.ts | 26 ++++ .../kube-types/src/kubevirt/V1Timer.ts | 56 ++++++++ .../kube-types/src/kubevirt/V1Toleration.ts | 50 +++++++ .../kubevirt/V1TypedLocalObjectReference.ts | 38 ++++++ .../src/kubevirt/V1VirtualMachine.ts | 54 ++++++++ .../src/kubevirt/V1VirtualMachineCondition.ts | 44 ++++++ .../src/kubevirt/V1VirtualMachineInstance.ts | 54 ++++++++ .../V1VirtualMachineInstanceCondition.ts | 44 ++++++ .../kubevirt/V1VirtualMachineInstanceList.ts | 47 +++++++ .../V1VirtualMachineInstanceMigration.ts | 54 ++++++++ ...irtualMachineInstanceMigrationCondition.ts | 44 ++++++ .../V1VirtualMachineInstanceMigrationList.ts | 47 +++++++ .../V1VirtualMachineInstanceMigrationSpec.ts | 26 ++++ .../V1VirtualMachineInstanceMigrationState.ts | 98 ++++++++++++++ ...V1VirtualMachineInstanceMigrationStatus.ts | 34 +++++ ...1VirtualMachineInstanceNetworkInterface.ts | 50 +++++++ .../V1VirtualMachineInstancePreset.ts | 47 +++++++ .../V1VirtualMachineInstancePresetList.ts | 47 +++++++ .../V1VirtualMachineInstancePresetSpec.ts | 35 +++++ .../V1VirtualMachineInstanceReplicaSet.ts | 54 ++++++++ ...rtualMachineInstanceReplicaSetCondition.ts | 44 ++++++ .../V1VirtualMachineInstanceReplicaSetList.ts | 47 +++++++ .../V1VirtualMachineInstanceReplicaSetSpec.ts | 47 +++++++ ...1VirtualMachineInstanceReplicaSetStatus.ts | 46 +++++++ .../kubevirt/V1VirtualMachineInstanceSpec.ts | 112 +++++++++++++++ .../V1VirtualMachineInstanceStatus.ts | 72 ++++++++++ .../V1VirtualMachineInstanceTemplateSpec.ts | 35 +++++ .../src/kubevirt/V1VirtualMachineList.ts | 47 +++++++ .../src/kubevirt/V1VirtualMachineSpec.ts | 47 +++++++ .../V1VirtualMachineStateChangeRequest.ts | 32 +++++ .../src/kubevirt/V1VirtualMachineStatus.ts | 47 +++++++ .../kube-types/src/kubevirt/V1Volume.ts | 104 ++++++++++++++ .../kube-types/src/kubevirt/V1WatchEvent.ts | 32 +++++ .../kube-types/src/kubevirt/V1Watchdog.ts | 34 +++++ .../src/kubevirt/V1WeightedPodAffinityTerm.ts | 34 +++++ .../src/kubevirt/V1alpha1DataVolume.ts | 54 ++++++++ .../src/kubevirt/V1alpha1DataVolumeSource.ts | 61 +++++++++ .../kubevirt/V1alpha1DataVolumeSourceHTTP.ts | 38 ++++++ .../kubevirt/V1alpha1DataVolumeSourcePVC.ts | 32 +++++ .../V1alpha1DataVolumeSourceRegistry.ts | 38 ++++++ .../kubevirt/V1alpha1DataVolumeSourceS3.ts | 32 +++++ .../src/kubevirt/V1alpha1DataVolumeSpec.ts | 41 ++++++ .../src/kubevirt/V1alpha1DataVolumeStatus.ts | 32 +++++ .../packages/kube-types/src/kubevirt/index.ts | 127 ++++++++++++++++++ 128 files changed, 5691 insertions(+) create mode 100644 frontend/packages/kube-types/src/kubevirt/V1APIGroup.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1APIGroupList.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1APIResource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1APIResourceList.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Affinity.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Bootloader.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1CDRomTarget.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1CPU.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1CPUFeature.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Clock.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1ClockOffsetUTC.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1CloudInitConfigDriveSource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1CloudInitNoCloudSource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1ConfigMapVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1ContainerDiskSource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1DHCPOptions.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1DHCPPrivateOptions.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1DataVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1DeleteOptions.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Devices.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Disk.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1DiskTarget.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1DomainSpec.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1EmptyDiskSource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1EphemeralVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1FeatureAPIC.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1FeatureHyperv.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1FeatureSpinlocks.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1FeatureState.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1FeatureVendorID.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Features.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Firmware.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1FloppyTarget.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1GenieNetwork.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1GroupVersionForDiscovery.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1HPETTimer.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1HTTPGetAction.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1HTTPHeader.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1HostDisk.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Hugepages.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1HypervTimer.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1I6300ESBWatchdog.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Initializer.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Initializers.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Input.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Interface.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1KVMTimer.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1LabelSelector.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1LabelSelectorRequirement.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1ListMeta.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1LocalObjectReference.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1LunTarget.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Machine.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Memory.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1MultusNetwork.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Network.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1NodeAffinity.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1NodeSelector.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1NodeSelectorRequirement.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1NodeSelectorTerm.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1ObjectMeta.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1OwnerReference.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1PITTimer.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1PersistentVolumeClaimSpec.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1PersistentVolumeClaimVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1PodAffinity.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1PodAffinityTerm.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1PodAntiAffinity.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1PodDNSConfig.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1PodDNSConfigOption.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1PodNetwork.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Port.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Preconditions.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1PreferredSchedulingTerm.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Probe.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1RTCTimer.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1ResourceRequirements.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1RootPaths.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1SecretVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1ServerAddressByClientCIDR.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1ServiceAccountVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Status.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1StatusCause.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1StatusDetails.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1TCPSocketAction.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Timer.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Toleration.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1TypedLocalObjectReference.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachine.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineCondition.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstance.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceCondition.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceList.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigration.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationCondition.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationList.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationSpec.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationState.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationStatus.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceNetworkInterface.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePreset.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePresetList.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePresetSpec.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSet.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetCondition.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetList.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetSpec.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetStatus.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceSpec.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceStatus.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceTemplateSpec.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineList.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineSpec.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineStateChangeRequest.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1VirtualMachineStatus.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Volume.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1WatchEvent.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1Watchdog.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1WeightedPodAffinityTerm.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolume.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSource.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceHTTP.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourcePVC.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceRegistry.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceS3.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSpec.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeStatus.ts create mode 100644 frontend/packages/kube-types/src/kubevirt/index.ts diff --git a/frontend/packages/kube-types/src/kubevirt/V1APIGroup.ts b/frontend/packages/kube-types/src/kubevirt/V1APIGroup.ts new file mode 100644 index 00000000000..88cd18e39dd --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1APIGroup.ts @@ -0,0 +1,59 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1GroupVersionForDiscovery } from './V1GroupVersionForDiscovery'; +import { V1ServerAddressByClientCIDR } from './V1ServerAddressByClientCIDR'; + +/** + * APIGroup contains the name, the supported versions, and the preferred version of a group. + * @export + * @interface V1APIGroup + */ +export interface V1APIGroup { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1APIGroup + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1APIGroup + */ + kind?: string; + /** + * name is the name of the group. + * @type {string} + * @memberof V1APIGroup + */ + name: string; + /** + * + * @type {V1GroupVersionForDiscovery} + * @memberof V1APIGroup + */ + preferredVersion?: V1GroupVersionForDiscovery; + /** + * a map of client CIDR to server address that is serving this group. This is to help clients reach servers in the most network-efficient way possible. Clients can use the appropriate server address as per the CIDR that they match. In case of multiple matches, clients should use the longest matching CIDR. The server returns only those CIDRs that it thinks that the client can match. For example: the master will return an internal IP CIDR only, if the client reaches the server using an internal IP. Server looks at X-Forwarded-For header or X-Real-Ip header or request.RemoteAddr (in that order) to get the client IP. + * @type {Array} + * @memberof V1APIGroup + */ + serverAddressByClientCIDRs?: V1ServerAddressByClientCIDR[]; + /** + * versions are the versions supported in this group. + * @type {Array} + * @memberof V1APIGroup + */ + versions: V1GroupVersionForDiscovery[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1APIGroupList.ts b/frontend/packages/kube-types/src/kubevirt/V1APIGroupList.ts new file mode 100644 index 00000000000..191e0542e5c --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1APIGroupList.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1APIGroup } from './V1APIGroup'; + +/** + * APIGroupList is a list of APIGroup, to allow clients to discover the API at /apis. + * @export + * @interface V1APIGroupList + */ +export interface V1APIGroupList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1APIGroupList + */ + apiVersion?: string; + /** + * groups is a list of APIGroup. + * @type {Array} + * @memberof V1APIGroupList + */ + groups: V1APIGroup[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1APIGroupList + */ + kind?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1APIResource.ts b/frontend/packages/kube-types/src/kubevirt/V1APIResource.ts new file mode 100644 index 00000000000..077aa375d01 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1APIResource.ts @@ -0,0 +1,74 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * APIResource specifies the name of a resource and whether it is namespaced. + * @export + * @interface V1APIResource + */ +export interface V1APIResource { + /** + * categories is a list of the grouped resources this resource belongs to (e.g. \'all\') + * @type {Array} + * @memberof V1APIResource + */ + categories?: string[]; + /** + * group is the preferred group of the resource. Empty implies the group of the containing resource list. For subresources, this may have a different value, for example: Scale\". + * @type {string} + * @memberof V1APIResource + */ + group?: string; + /** + * kind is the kind for the resource (e.g. \'Foo\' is the kind for a resource \'foo\') + * @type {string} + * @memberof V1APIResource + */ + kind: string; + /** + * name is the plural name of the resource. + * @type {string} + * @memberof V1APIResource + */ + name: string; + /** + * namespaced indicates if a resource is namespaced or not. + * @type {boolean} + * @memberof V1APIResource + */ + namespaced: boolean; + /** + * shortNames is a list of suggested short names of the resource. + * @type {Array} + * @memberof V1APIResource + */ + shortNames?: string[]; + /** + * singularName is the singular name of the resource. This allows clients to handle plural and singular opaquely. The singularName is more correct for reporting status on a single item and both singular and plural are allowed from the kubectl CLI interface. + * @type {string} + * @memberof V1APIResource + */ + singularName: string; + /** + * verbs is a list of supported kube verbs (this includes get, list, watch, create, update, patch, delete, deletecollection, and proxy) + * @type {Array} + * @memberof V1APIResource + */ + verbs: string[]; + /** + * version is the preferred version of the resource. Empty implies the version of the containing resource list For subresources, this may have a different value, for example: v1 (while inside a v1beta1 version of the core resource\'s group)\". + * @type {string} + * @memberof V1APIResource + */ + version?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1APIResourceList.ts b/frontend/packages/kube-types/src/kubevirt/V1APIResourceList.ts new file mode 100644 index 00000000000..20d606c73d4 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1APIResourceList.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1APIResource } from './V1APIResource'; + +/** + * APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced. + * @export + * @interface V1APIResourceList + */ +export interface V1APIResourceList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1APIResourceList + */ + apiVersion?: string; + /** + * groupVersion is the group and version this APIResourceList is for. + * @type {string} + * @memberof V1APIResourceList + */ + groupVersion: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1APIResourceList + */ + kind?: string; + /** + * resources contains the name of the resources and if they are namespaced. + * @type {Array} + * @memberof V1APIResourceList + */ + resources: V1APIResource[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Affinity.ts b/frontend/packages/kube-types/src/kubevirt/V1Affinity.ts new file mode 100644 index 00000000000..d63bb0d40ab --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Affinity.ts @@ -0,0 +1,42 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeAffinity } from './V1NodeAffinity'; +import { V1PodAffinity } from './V1PodAffinity'; +import { V1PodAntiAffinity } from './V1PodAntiAffinity'; + +/** + * Affinity is a group of affinity scheduling rules. + * @export + * @interface V1Affinity + */ +export interface V1Affinity { + /** + * + * @type {V1NodeAffinity} + * @memberof V1Affinity + */ + nodeAffinity?: V1NodeAffinity; + /** + * + * @type {V1PodAffinity} + * @memberof V1Affinity + */ + podAffinity?: V1PodAffinity; + /** + * + * @type {V1PodAntiAffinity} + * @memberof V1Affinity + */ + podAntiAffinity?: V1PodAntiAffinity; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Bootloader.ts b/frontend/packages/kube-types/src/kubevirt/V1Bootloader.ts new file mode 100644 index 00000000000..d58b0502f88 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Bootloader.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents the firmware blob used to assist in the domain creation process. Used for setting the QEMU BIOS file path for the libvirt domain. + * @export + * @interface V1Bootloader + */ +export interface V1Bootloader { + /** + * If set (default), BIOS will be used. + * @type {object} + * @memberof V1Bootloader + */ + bios?: object; + /** + * If set, EFI will be used instead of BIOS. + * @type {object} + * @memberof V1Bootloader + */ + efi?: object; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1CDRomTarget.ts b/frontend/packages/kube-types/src/kubevirt/V1CDRomTarget.ts new file mode 100644 index 00000000000..727304fd4be --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1CDRomTarget.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1CDRomTarget + */ +export interface V1CDRomTarget { + /** + * Bus indicates the type of disk device to emulate. supported values: virtio, sata, scsi. + * @type {string} + * @memberof V1CDRomTarget + */ + bus?: string; + /** + * ReadOnly. Defaults to true. + * @type {boolean} + * @memberof V1CDRomTarget + */ + readonly?: boolean; + /** + * Tray indicates if the tray of the device is open or closed. Allowed values are \"open\" and \"closed\". Defaults to closed. +optional + * @type {string} + * @memberof V1CDRomTarget + */ + tray?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1CPU.ts b/frontend/packages/kube-types/src/kubevirt/V1CPU.ts new file mode 100644 index 00000000000..25b9b16a530 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1CPU.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1CPUFeature } from './V1CPUFeature'; + +/** + * CPU allows specifying the CPU topology. + * @export + * @interface V1CPU + */ +export interface V1CPU { + /** + * Cores specifies the number of cores inside the vmi. Must be a value greater or equal 1. + * @type {number} + * @memberof V1CPU + */ + cores?: number; + /** + * DedicatedCPUPlacement requests the scheduler to place the VirtualMachineInstance on a node with enough dedicated pCPUs and pin the vCPUs to it. +optional + * @type {boolean} + * @memberof V1CPU + */ + dedicatedCpuPlacement?: boolean; + /** + * Features specifies the CPU features list inside the VMI. +optional + * @type {Array} + * @memberof V1CPU + */ + features?: V1CPUFeature[]; + /** + * Model specifies the CPU model inside the VMI. List of available models https://github.com/libvirt/libvirt/tree/master/src/cpu_map. It is possible to specify special cases like \"host-passthrough\" to get the same CPU as the node and \"host-model\" to get CPU closest to the node one. Defaults to host-model. +optional + * @type {string} + * @memberof V1CPU + */ + model?: string; + /** + * Sockets specifies the number of sockets inside the vmi. Must be a value greater or equal 1. + * @type {number} + * @memberof V1CPU + */ + sockets?: number; + /** + * Threads specifies the number of threads inside the vmi. Must be a value greater or equal 1. + * @type {number} + * @memberof V1CPU + */ + threads?: number; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1CPUFeature.ts b/frontend/packages/kube-types/src/kubevirt/V1CPUFeature.ts new file mode 100644 index 00000000000..9b8327a2b5a --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1CPUFeature.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * CPUFeature allows specifying a CPU feature. + * @export + * @interface V1CPUFeature + */ +export interface V1CPUFeature { + /** + * Name of the CPU feature + * @type {string} + * @memberof V1CPUFeature + */ + name: string; + /** + * Policy is the CPU feature attribute which can have the following attributes: force - The virtual CPU will claim the feature is supported regardless of it being supported by host CPU. require - Guest creation will fail unless the feature is supported by the host CPU or the hypervisor is able to emulate it. optional - The feature will be supported by virtual CPU if and only if it is supported by host CPU. disable - The feature will not be supported by virtual CPU. forbid - Guest creation will fail if the feature is supported by host CPU. Defaults to require +optional + * @type {string} + * @memberof V1CPUFeature + */ + policy?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Clock.ts b/frontend/packages/kube-types/src/kubevirt/V1Clock.ts new file mode 100644 index 00000000000..7bd2209f016 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Clock.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ClockOffsetUTC } from './V1ClockOffsetUTC'; +import { V1Timer } from './V1Timer'; + +/** + * Represents the clock and timers of a vmi. + * @export + * @interface V1Clock + */ +export interface V1Clock { + /** + * + * @type {V1Timer} + * @memberof V1Clock + */ + timer: V1Timer; + /** + * + * @type {object} + * @memberof V1Clock + */ + timezone?: object; + /** + * + * @type {V1ClockOffsetUTC} + * @memberof V1Clock + */ + utc?: V1ClockOffsetUTC; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1ClockOffsetUTC.ts b/frontend/packages/kube-types/src/kubevirt/V1ClockOffsetUTC.ts new file mode 100644 index 00000000000..d644e05ba01 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1ClockOffsetUTC.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * UTC sets the guest clock to UTC on each boot. + * @export + * @interface V1ClockOffsetUTC + */ +export interface V1ClockOffsetUTC { + /** + * OffsetSeconds specifies an offset in seconds, relative to UTC. If set, guest changes to the clock will be kept during reboots and not reset. + * @type {number} + * @memberof V1ClockOffsetUTC + */ + offsetSeconds?: number; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1CloudInitConfigDriveSource.ts b/frontend/packages/kube-types/src/kubevirt/V1CloudInitConfigDriveSource.ts new file mode 100644 index 00000000000..e8f5a731499 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1CloudInitConfigDriveSource.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * Represents a cloud-init config drive user data source. More info: https://cloudinit.readthedocs.io/en/latest/topics/datasources/configdrive.html + * @export + * @interface V1CloudInitConfigDriveSource + */ +export interface V1CloudInitConfigDriveSource { + /** + * NetworkData contains config drive inline cloud-init networkdata. + optional + * @type {string} + * @memberof V1CloudInitConfigDriveSource + */ + networkData?: string; + /** + * NetworkDataBase64 contains config drive cloud-init networkdata as a base64 encoded string. + optional + * @type {string} + * @memberof V1CloudInitConfigDriveSource + */ + networkDataBase64?: string; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1CloudInitConfigDriveSource + */ + networkDataSecretRef?: V1LocalObjectReference; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1CloudInitConfigDriveSource + */ + secretRef?: V1LocalObjectReference; + /** + * UserData contains config drive inline cloud-init userdata. + optional + * @type {string} + * @memberof V1CloudInitConfigDriveSource + */ + userData?: string; + /** + * UserDataBase64 contains config drive cloud-init userdata as a base64 encoded string. + optional + * @type {string} + * @memberof V1CloudInitConfigDriveSource + */ + userDataBase64?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1CloudInitNoCloudSource.ts b/frontend/packages/kube-types/src/kubevirt/V1CloudInitNoCloudSource.ts new file mode 100644 index 00000000000..4605d57ecac --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1CloudInitNoCloudSource.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LocalObjectReference } from './V1LocalObjectReference'; + +/** + * Represents a cloud-init nocloud user data source. More info: http://cloudinit.readthedocs.io/en/latest/topics/datasources/nocloud.html + * @export + * @interface V1CloudInitNoCloudSource + */ +export interface V1CloudInitNoCloudSource { + /** + * NetworkData contains NoCloud inline cloud-init networkdata. + optional + * @type {string} + * @memberof V1CloudInitNoCloudSource + */ + networkData?: string; + /** + * NetworkDataBase64 contains NoCloud cloud-init networkdata as a base64 encoded string. + optional + * @type {string} + * @memberof V1CloudInitNoCloudSource + */ + networkDataBase64?: string; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1CloudInitNoCloudSource + */ + networkDataSecretRef?: V1LocalObjectReference; + /** + * + * @type {V1LocalObjectReference} + * @memberof V1CloudInitNoCloudSource + */ + secretRef?: V1LocalObjectReference; + /** + * UserData contains NoCloud inline cloud-init userdata. + optional + * @type {string} + * @memberof V1CloudInitNoCloudSource + */ + userData?: string; + /** + * UserDataBase64 contains NoCloud cloud-init userdata as a base64 encoded string. + optional + * @type {string} + * @memberof V1CloudInitNoCloudSource + */ + userDataBase64?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1ConfigMapVolumeSource.ts b/frontend/packages/kube-types/src/kubevirt/V1ConfigMapVolumeSource.ts new file mode 100644 index 00000000000..8906314747d --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1ConfigMapVolumeSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ConfigMapVolumeSource adapts a ConfigMap into a volume. More info: https://kubernetes.io/docs/concepts/storage/volumes/#configmap + * @export + * @interface V1ConfigMapVolumeSource + */ +export interface V1ConfigMapVolumeSource { + /** + * Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1ConfigMapVolumeSource + */ + name?: string; + /** + * Specify whether the ConfigMap or it\'s keys must be defined +optional + * @type {boolean} + * @memberof V1ConfigMapVolumeSource + */ + optional?: boolean; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1ContainerDiskSource.ts b/frontend/packages/kube-types/src/kubevirt/V1ContainerDiskSource.ts new file mode 100644 index 00000000000..5ed16f9dc16 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1ContainerDiskSource.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a docker image with an embedded disk. + * @export + * @interface V1ContainerDiskSource + */ +export interface V1ContainerDiskSource { + /** + * Image is the name of the image with the embedded disk. + * @type {string} + * @memberof V1ContainerDiskSource + */ + image: string; + /** + * Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images +optional + * @type {string} + * @memberof V1ContainerDiskSource + */ + imagePullPolicy?: string; + /** + * ImagePullSecret is the name of the Docker registry secret required to pull the image. The secret must already exist. + * @type {string} + * @memberof V1ContainerDiskSource + */ + imagePullSecret?: string; + /** + * Path defines the path to disk file in the container + * @type {string} + * @memberof V1ContainerDiskSource + */ + path?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1DHCPOptions.ts b/frontend/packages/kube-types/src/kubevirt/V1DHCPOptions.ts new file mode 100644 index 00000000000..8925d27f626 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1DHCPOptions.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DHCPPrivateOptions } from './V1DHCPPrivateOptions'; + +/** + * Extra DHCP options to use in the interface. + * @export + * @interface V1DHCPOptions + */ +export interface V1DHCPOptions { + /** + * If specified will pass option 67 to interface\'s DHCP server +optional + * @type {string} + * @memberof V1DHCPOptions + */ + bootFileName?: string; + /** + * If specified will pass the configured NTP server to the VM via DHCP option 042. +optional + * @type {Array} + * @memberof V1DHCPOptions + */ + ntpServers?: string[]; + /** + * If specified will pass extra DHCP options for private use, range: 224-254 +optional + * @type {Array} + * @memberof V1DHCPOptions + */ + privateOptions?: V1DHCPPrivateOptions[]; + /** + * If specified will pass option 66 to interface\'s DHCP server +optional + * @type {string} + * @memberof V1DHCPOptions + */ + tftpServerName?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1DHCPPrivateOptions.ts b/frontend/packages/kube-types/src/kubevirt/V1DHCPPrivateOptions.ts new file mode 100644 index 00000000000..7dd9aba5aa5 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1DHCPPrivateOptions.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DHCPExtraOptions defines Extra DHCP options for a VM. + * @export + * @interface V1DHCPPrivateOptions + */ +export interface V1DHCPPrivateOptions { + /** + * Option is an Integer value from 224-254 Required. + * @type {number} + * @memberof V1DHCPPrivateOptions + */ + option: number; + /** + * Value is a String value for the Option provided Required. + * @type {string} + * @memberof V1DHCPPrivateOptions + */ + value: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1DataVolumeSource.ts b/frontend/packages/kube-types/src/kubevirt/V1DataVolumeSource.ts new file mode 100644 index 00000000000..e909043e51b --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1DataVolumeSource.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1DataVolumeSource + */ +export interface V1DataVolumeSource { + /** + * Name represents the name of the DataVolume in the same namespace + * @type {string} + * @memberof V1DataVolumeSource + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1DeleteOptions.ts b/frontend/packages/kube-types/src/kubevirt/V1DeleteOptions.ts new file mode 100644 index 00000000000..947e8fc2fa7 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1DeleteOptions.ts @@ -0,0 +1,64 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Preconditions } from './V1Preconditions'; + +/** + * DeleteOptions may be provided when deleting an API object. + * @export + * @interface V1DeleteOptions + */ +export interface V1DeleteOptions { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1DeleteOptions + */ + apiVersion?: 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 + * @type {Array} + * @memberof V1DeleteOptions + */ + 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. + * @type {number} + * @memberof V1DeleteOptions + */ + gracePeriodSeconds?: number; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1DeleteOptions + */ + kind?: string; + /** + * Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object\'s finalizers list. Either this field or PropagationPolicy may be set, but not both. + * @type {boolean} + * @memberof V1DeleteOptions + */ + orphanDependents?: boolean; + /** + * + * @type {V1Preconditions} + * @memberof V1DeleteOptions + */ + preconditions?: V1Preconditions; + /** + * + * @type {object} + * @memberof V1DeleteOptions + */ + propagationPolicy?: object; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Devices.ts b/frontend/packages/kube-types/src/kubevirt/V1Devices.ts new file mode 100644 index 00000000000..eb5df8044a1 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Devices.ts @@ -0,0 +1,79 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Disk } from './V1Disk'; +import { V1Input } from './V1Input'; +import { V1Interface } from './V1Interface'; +import { V1Watchdog } from './V1Watchdog'; + +/** + * + * @export + * @interface V1Devices + */ +export interface V1Devices { + /** + * Whether to attach the default graphics device or not. VNC will not be available if set to false. Defaults to true. + * @type {boolean} + * @memberof V1Devices + */ + autoattachGraphicsDevice?: boolean; + /** + * Whether to attach a pod network interface. Defaults to true. + * @type {boolean} + * @memberof V1Devices + */ + autoattachPodInterface?: boolean; + /** + * Whether or not to enable virtio multi-queue for block devices +optional + * @type {boolean} + * @memberof V1Devices + */ + blockMultiQueue?: boolean; + /** + * Disks describes disks, cdroms, floppy and luns which are connected to the vmi. + * @type {Array} + * @memberof V1Devices + */ + disks?: V1Disk[]; + /** + * Inputs describe input devices + * @type {Array} + * @memberof V1Devices + */ + inputs?: V1Input[]; + /** + * Interfaces describe network interfaces which are added to the vmi. + * @type {Array} + * @memberof V1Devices + */ + interfaces?: V1Interface[]; + /** + * If specified, virtual network interfaces configured with a virtio bus will also enable the vhost multiqueue feature +optional + * @type {boolean} + * @memberof V1Devices + */ + networkInterfaceMultiqueue?: boolean; + /** + * Rng represents the random device passed from host + * @type {object} + * @memberof V1Devices + */ + rng?: object; + /** + * + * @type {V1Watchdog} + * @memberof V1Devices + */ + watchdog?: V1Watchdog; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Disk.ts b/frontend/packages/kube-types/src/kubevirt/V1Disk.ts new file mode 100644 index 00000000000..8d612ae2b20 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Disk.ts @@ -0,0 +1,79 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1CDRomTarget } from './V1CDRomTarget'; +import { V1DiskTarget } from './V1DiskTarget'; +import { V1FloppyTarget } from './V1FloppyTarget'; +import { V1LunTarget } from './V1LunTarget'; + +/** + * + * @export + * @interface V1Disk + */ +export interface V1Disk { + /** + * BootOrder is an integer value > 0, used to determine ordering of boot devices. Lower values take precedence. Each disk or interface that has a boot order must have a unique value. Disks without a boot order are not tried if a disk with a boot order exists. +optional + * @type {number} + * @memberof V1Disk + */ + bootOrder?: number; + /** + * Cache specifies which kvm disk cache mode should be used. +optional + * @type {string} + * @memberof V1Disk + */ + cache?: string; + /** + * + * @type {V1CDRomTarget} + * @memberof V1Disk + */ + cdrom?: V1CDRomTarget; + /** + * dedicatedIOThread indicates this disk should have an exclusive IO Thread. Enabling this implies useIOThreads = true. Defaults to false. +optional + * @type {boolean} + * @memberof V1Disk + */ + dedicatedIOThread?: boolean; + /** + * + * @type {V1DiskTarget} + * @memberof V1Disk + */ + disk?: V1DiskTarget; + /** + * + * @type {V1FloppyTarget} + * @memberof V1Disk + */ + floppy?: V1FloppyTarget; + /** + * + * @type {V1LunTarget} + * @memberof V1Disk + */ + lun?: V1LunTarget; + /** + * Name is the device name + * @type {string} + * @memberof V1Disk + */ + name: string; + /** + * Serial provides the ability to specify a serial number for the disk device. +optional + * @type {string} + * @memberof V1Disk + */ + serial?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1DiskTarget.ts b/frontend/packages/kube-types/src/kubevirt/V1DiskTarget.ts new file mode 100644 index 00000000000..1e18bb3a2c2 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1DiskTarget.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1DiskTarget + */ +export interface V1DiskTarget { + /** + * Bus indicates the type of disk device to emulate. supported values: virtio, sata, scsi. + * @type {string} + * @memberof V1DiskTarget + */ + bus?: string; + /** + * If specified, the virtual disk will be placed on the guests pci address with the specifed PCI address. For example: 0000:81:01.10 +optional + * @type {string} + * @memberof V1DiskTarget + */ + pciAddress?: string; + /** + * ReadOnly. Defaults to false. + * @type {boolean} + * @memberof V1DiskTarget + */ + readonly?: boolean; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1DomainSpec.ts b/frontend/packages/kube-types/src/kubevirt/V1DomainSpec.ts new file mode 100644 index 00000000000..df5848914ba --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1DomainSpec.ts @@ -0,0 +1,83 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1CPU } from './V1CPU'; +import { V1Clock } from './V1Clock'; +import { V1Devices } from './V1Devices'; +import { V1Features } from './V1Features'; +import { V1Firmware } from './V1Firmware'; +import { V1Machine } from './V1Machine'; +import { V1Memory } from './V1Memory'; +import { V1ResourceRequirements } from './V1ResourceRequirements'; + +/** + * + * @export + * @interface V1DomainSpec + */ +export interface V1DomainSpec { + /** + * + * @type {V1Clock} + * @memberof V1DomainSpec + */ + clock?: V1Clock; + /** + * + * @type {V1CPU} + * @memberof V1DomainSpec + */ + cpu?: V1CPU; + /** + * + * @type {V1Devices} + * @memberof V1DomainSpec + */ + devices: V1Devices; + /** + * + * @type {V1Features} + * @memberof V1DomainSpec + */ + features?: V1Features; + /** + * + * @type {V1Firmware} + * @memberof V1DomainSpec + */ + firmware?: V1Firmware; + /** + * + * @type {object} + * @memberof V1DomainSpec + */ + ioThreadsPolicy?: object; + /** + * + * @type {V1Machine} + * @memberof V1DomainSpec + */ + machine?: V1Machine; + /** + * + * @type {V1Memory} + * @memberof V1DomainSpec + */ + memory?: V1Memory; + /** + * + * @type {V1ResourceRequirements} + * @memberof V1DomainSpec + */ + resources?: V1ResourceRequirements; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1EmptyDiskSource.ts b/frontend/packages/kube-types/src/kubevirt/V1EmptyDiskSource.ts new file mode 100644 index 00000000000..b596424cf3d --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1EmptyDiskSource.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * EmptyDisk represents a temporary disk which shares the vmis lifecycle. + * @export + * @interface V1EmptyDiskSource + */ +export interface V1EmptyDiskSource { + /** + * Capacity of the sparse disk. + * @type {string} + * @memberof V1EmptyDiskSource + */ + capacity: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1EphemeralVolumeSource.ts b/frontend/packages/kube-types/src/kubevirt/V1EphemeralVolumeSource.ts new file mode 100644 index 00000000000..4e68bb5afc7 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1EphemeralVolumeSource.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PersistentVolumeClaimVolumeSource } from './V1PersistentVolumeClaimVolumeSource'; + +/** + * + * @export + * @interface V1EphemeralVolumeSource + */ +export interface V1EphemeralVolumeSource { + /** + * + * @type {V1PersistentVolumeClaimVolumeSource} + * @memberof V1EphemeralVolumeSource + */ + persistentVolumeClaim?: V1PersistentVolumeClaimVolumeSource; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1FeatureAPIC.ts b/frontend/packages/kube-types/src/kubevirt/V1FeatureAPIC.ts new file mode 100644 index 00000000000..4c22f2d5676 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1FeatureAPIC.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1FeatureAPIC + */ +export interface V1FeatureAPIC { + /** + * Enabled determines if the feature should be enabled or disabled on the guest. Defaults to true. +optional + * @type {boolean} + * @memberof V1FeatureAPIC + */ + enabled?: boolean; + /** + * EndOfInterrupt enables the end of interrupt notification in the guest. Defaults to false. +optional + * @type {boolean} + * @memberof V1FeatureAPIC + */ + endOfInterrupt?: boolean; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1FeatureHyperv.ts b/frontend/packages/kube-types/src/kubevirt/V1FeatureHyperv.ts new file mode 100644 index 00000000000..1b257c98454 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1FeatureHyperv.ts @@ -0,0 +1,108 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1FeatureSpinlocks } from './V1FeatureSpinlocks'; +import { V1FeatureState } from './V1FeatureState'; +import { V1FeatureVendorID } from './V1FeatureVendorID'; + +/** + * Hyperv specific features. + * @export + * @interface V1FeatureHyperv + */ +export interface V1FeatureHyperv { + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + evmcs?: V1FeatureState; + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + frequencies?: V1FeatureState; + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + ipi?: V1FeatureState; + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + reenlightenment?: V1FeatureState; + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + relaxed?: V1FeatureState; + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + reset?: V1FeatureState; + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + runtime?: V1FeatureState; + /** + * + * @type {V1FeatureSpinlocks} + * @memberof V1FeatureHyperv + */ + spinlocks?: V1FeatureSpinlocks; + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + synic?: V1FeatureState; + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + synictimer?: V1FeatureState; + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + tlbflush?: V1FeatureState; + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + vapic?: V1FeatureState; + /** + * + * @type {V1FeatureVendorID} + * @memberof V1FeatureHyperv + */ + vendorid?: V1FeatureVendorID; + /** + * + * @type {V1FeatureState} + * @memberof V1FeatureHyperv + */ + vpindex?: V1FeatureState; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1FeatureSpinlocks.ts b/frontend/packages/kube-types/src/kubevirt/V1FeatureSpinlocks.ts new file mode 100644 index 00000000000..11135d84d0a --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1FeatureSpinlocks.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1FeatureSpinlocks + */ +export interface V1FeatureSpinlocks { + /** + * Enabled determines if the feature should be enabled or disabled on the guest. Defaults to true. +optional + * @type {boolean} + * @memberof V1FeatureSpinlocks + */ + enabled?: boolean; + /** + * Retries indicates the number of retries. Must be a value greater or equal 4096. Defaults to 4096. +optional + * @type {number} + * @memberof V1FeatureSpinlocks + */ + spinlocks?: number; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1FeatureState.ts b/frontend/packages/kube-types/src/kubevirt/V1FeatureState.ts new file mode 100644 index 00000000000..18ed4efc0f1 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1FeatureState.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents if a feature is enabled or disabled. + * @export + * @interface V1FeatureState + */ +export interface V1FeatureState { + /** + * Enabled determines if the feature should be enabled or disabled on the guest. Defaults to true. +optional + * @type {boolean} + * @memberof V1FeatureState + */ + enabled?: boolean; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1FeatureVendorID.ts b/frontend/packages/kube-types/src/kubevirt/V1FeatureVendorID.ts new file mode 100644 index 00000000000..fb9434ee4ed --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1FeatureVendorID.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1FeatureVendorID + */ +export interface V1FeatureVendorID { + /** + * Enabled determines if the feature should be enabled or disabled on the guest. Defaults to true. +optional + * @type {boolean} + * @memberof V1FeatureVendorID + */ + enabled?: boolean; + /** + * VendorID sets the hypervisor vendor id, visible to the vmi. String up to twelve characters. + * @type {string} + * @memberof V1FeatureVendorID + */ + vendorid?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Features.ts b/frontend/packages/kube-types/src/kubevirt/V1Features.ts new file mode 100644 index 00000000000..5c821842d12 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Features.ts @@ -0,0 +1,48 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1FeatureAPIC } from './V1FeatureAPIC'; +import { V1FeatureHyperv } from './V1FeatureHyperv'; +import { V1FeatureState } from './V1FeatureState'; + +/** + * + * @export + * @interface V1Features + */ +export interface V1Features { + /** + * + * @type {V1FeatureState} + * @memberof V1Features + */ + acpi?: V1FeatureState; + /** + * + * @type {V1FeatureAPIC} + * @memberof V1Features + */ + apic?: V1FeatureAPIC; + /** + * + * @type {V1FeatureHyperv} + * @memberof V1Features + */ + hyperv?: V1FeatureHyperv; + /** + * + * @type {V1FeatureState} + * @memberof V1Features + */ + smm?: V1FeatureState; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Firmware.ts b/frontend/packages/kube-types/src/kubevirt/V1Firmware.ts new file mode 100644 index 00000000000..55ee26e63a3 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Firmware.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Bootloader } from './V1Bootloader'; + +/** + * + * @export + * @interface V1Firmware + */ +export interface V1Firmware { + /** + * + * @type {V1Bootloader} + * @memberof V1Firmware + */ + bootloader?: V1Bootloader; + /** + * The system-serial-number in SMBIOS + * @type {string} + * @memberof V1Firmware + */ + serial?: string; + /** + * UUID reported by the vmi bios. Defaults to a random generated uid. + * @type {string} + * @memberof V1Firmware + */ + uuid?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1FloppyTarget.ts b/frontend/packages/kube-types/src/kubevirt/V1FloppyTarget.ts new file mode 100644 index 00000000000..01ebcf63e37 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1FloppyTarget.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1FloppyTarget + */ +export interface V1FloppyTarget { + /** + * ReadOnly. Defaults to false. + * @type {boolean} + * @memberof V1FloppyTarget + */ + readonly?: boolean; + /** + * Tray indicates if the tray of the device is open or closed. Allowed values are \"open\" and \"closed\". Defaults to closed. +optional + * @type {string} + * @memberof V1FloppyTarget + */ + tray?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1GenieNetwork.ts b/frontend/packages/kube-types/src/kubevirt/V1GenieNetwork.ts new file mode 100644 index 00000000000..ee9336c877c --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1GenieNetwork.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents the genie cni network. + * @export + * @interface V1GenieNetwork + */ +export interface V1GenieNetwork { + /** + * References the CNI plugin name. + * @type {string} + * @memberof V1GenieNetwork + */ + networkName: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1GroupVersionForDiscovery.ts b/frontend/packages/kube-types/src/kubevirt/V1GroupVersionForDiscovery.ts new file mode 100644 index 00000000000..abd03f26a38 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1GroupVersionForDiscovery.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * GroupVersion contains the \"group/version\" and \"version\" string of a version. It is made a struct to keep extensibility. + * @export + * @interface V1GroupVersionForDiscovery + */ +export interface V1GroupVersionForDiscovery { + /** + * groupVersion specifies the API group and version in the form \"group/version\" + * @type {string} + * @memberof V1GroupVersionForDiscovery + */ + groupVersion: string; + /** + * version specifies the version in the form of \"version\". This is to save the clients the trouble of splitting the GroupVersion. + * @type {string} + * @memberof V1GroupVersionForDiscovery + */ + version: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1HPETTimer.ts b/frontend/packages/kube-types/src/kubevirt/V1HPETTimer.ts new file mode 100644 index 00000000000..a648ac7fae5 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1HPETTimer.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1HPETTimer + */ +export interface V1HPETTimer { + /** + * Enabled set to false makes sure that the machine type or a preset can\'t add the timer. Defaults to true. +optional + * @type {boolean} + * @memberof V1HPETTimer + */ + present?: boolean; + /** + * TickPolicy determines what happens when QEMU misses a deadline for injecting a tick to the guest. One of \"delay\", \"catchup\", \"merge\", \"discard\". + * @type {string} + * @memberof V1HPETTimer + */ + tickPolicy?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1HTTPGetAction.ts b/frontend/packages/kube-types/src/kubevirt/V1HTTPGetAction.ts new file mode 100644 index 00000000000..70f21e34278 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1HTTPGetAction.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1HTTPHeader } from './V1HTTPHeader'; + +/** + * HTTPGetAction describes an action based on HTTP Get requests. + * @export + * @interface V1HTTPGetAction + */ +export interface V1HTTPGetAction { + /** + * Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead. + * @type {string} + * @memberof V1HTTPGetAction + */ + host?: string; + /** + * Custom headers to set in the request. HTTP allows repeated headers. + * @type {Array} + * @memberof V1HTTPGetAction + */ + httpHeaders?: V1HTTPHeader[]; + /** + * Path to access on the HTTP server. + * @type {string} + * @memberof V1HTTPGetAction + */ + path?: string; + /** + * Scheme to use for connecting to the host. Defaults to HTTP. + * @type {string} + * @memberof V1HTTPGetAction + */ + scheme?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1HTTPHeader.ts b/frontend/packages/kube-types/src/kubevirt/V1HTTPHeader.ts new file mode 100644 index 00000000000..b2a3afb74e8 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1HTTPHeader.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * HTTPHeader describes a custom header to be used in HTTP probes + * @export + * @interface V1HTTPHeader + */ +export interface V1HTTPHeader { + /** + * The header field name + * @type {string} + * @memberof V1HTTPHeader + */ + name: string; + /** + * The header field value + * @type {string} + * @memberof V1HTTPHeader + */ + value: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1HostDisk.ts b/frontend/packages/kube-types/src/kubevirt/V1HostDisk.ts new file mode 100644 index 00000000000..6c33c1a1fae --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1HostDisk.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents a disk created on the cluster level + * @export + * @interface V1HostDisk + */ +export interface V1HostDisk { + /** + * Capacity of the sparse disk +optional + * @type {string} + * @memberof V1HostDisk + */ + capacity?: string; + /** + * The path to HostDisk image located on the cluster + * @type {string} + * @memberof V1HostDisk + */ + path: string; + /** + * Shared indicate whether the path is shared between nodes + * @type {boolean} + * @memberof V1HostDisk + */ + shared?: boolean; + /** + * Contains information if disk.img exists or should be created allowed options are \'Disk\' and \'DiskOrCreate\' + * @type {string} + * @memberof V1HostDisk + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Hugepages.ts b/frontend/packages/kube-types/src/kubevirt/V1Hugepages.ts new file mode 100644 index 00000000000..d5ea1ca3595 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Hugepages.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Hugepages allow to use hugepages for the VirtualMachineInstance instead of regular memory. + * @export + * @interface V1Hugepages + */ +export interface V1Hugepages { + /** + * PageSize specifies the hugepage size, for x86_64 architecture valid values are 1Gi and 2Mi. + * @type {string} + * @memberof V1Hugepages + */ + pageSize?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1HypervTimer.ts b/frontend/packages/kube-types/src/kubevirt/V1HypervTimer.ts new file mode 100644 index 00000000000..9bc8694e0e1 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1HypervTimer.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1HypervTimer + */ +export interface V1HypervTimer { + /** + * Enabled set to false makes sure that the machine type or a preset can\'t add the timer. Defaults to true. +optional + * @type {boolean} + * @memberof V1HypervTimer + */ + present?: boolean; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1I6300ESBWatchdog.ts b/frontend/packages/kube-types/src/kubevirt/V1I6300ESBWatchdog.ts new file mode 100644 index 00000000000..9b000e5f6e3 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1I6300ESBWatchdog.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * i6300esb watchdog device. + * @export + * @interface V1I6300ESBWatchdog + */ +export interface V1I6300ESBWatchdog { + /** + * The action to take. Valid values are poweroff, reset, shutdown. Defaults to reset. + * @type {string} + * @memberof V1I6300ESBWatchdog + */ + action?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Initializer.ts b/frontend/packages/kube-types/src/kubevirt/V1Initializer.ts new file mode 100644 index 00000000000..8fc95dcdcf7 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Initializer.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Initializer is information about an initializer that has not yet completed. + * @export + * @interface V1Initializer + */ +export interface V1Initializer { + /** + * name of the process that is responsible for initializing this object. + * @type {string} + * @memberof V1Initializer + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Initializers.ts b/frontend/packages/kube-types/src/kubevirt/V1Initializers.ts new file mode 100644 index 00000000000..36e7ca29cb9 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Initializers.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Initializer } from './V1Initializer'; +import { V1Status } from './V1Status'; + +/** + * Initializers tracks the progress of initialization. + * @export + * @interface V1Initializers + */ +export interface V1Initializers { + /** + * Pending is a list of initializers that must execute in order before this object is visible. When the last pending initializer is removed, and no failing result is set, the initializers struct will be set to nil and the object is considered as initialized and visible to all clients. + * @type {Array} + * @memberof V1Initializers + */ + pending: V1Initializer[]; + /** + * + * @type {V1Status} + * @memberof V1Initializers + */ + result?: V1Status; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Input.ts b/frontend/packages/kube-types/src/kubevirt/V1Input.ts new file mode 100644 index 00000000000..280bb631d17 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Input.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1Input + */ +export interface V1Input { + /** + * Bus indicates the bus of input device to emulate. Supported values: virtio, usb. + * @type {string} + * @memberof V1Input + */ + bus?: string; + /** + * Name is the device name + * @type {string} + * @memberof V1Input + */ + name: string; + /** + * Type indicated the type of input device. Supported values: tablet. + * @type {string} + * @memberof V1Input + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Interface.ts b/frontend/packages/kube-types/src/kubevirt/V1Interface.ts new file mode 100644 index 00000000000..c5d81da35b7 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Interface.ts @@ -0,0 +1,89 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DHCPOptions } from './V1DHCPOptions'; +import { V1Port } from './V1Port'; + +/** + * + * @export + * @interface V1Interface + */ +export interface V1Interface { + /** + * BootOrder is an integer value > 0, used to determine ordering of boot devices. Lower values take precedence. Each interface or disk that has a boot order must have a unique value. Interfaces without a boot order are not tried. +optional + * @type {number} + * @memberof V1Interface + */ + bootOrder?: number; + /** + * + * @type {object} + * @memberof V1Interface + */ + bridge?: object; + /** + * + * @type {V1DHCPOptions} + * @memberof V1Interface + */ + dhcpOptions?: V1DHCPOptions; + /** + * Interface MAC address. For example: de:ad:00:00:be:af or DE-AD-00-00-BE-AF. + * @type {string} + * @memberof V1Interface + */ + macAddress?: string; + /** + * + * @type {object} + * @memberof V1Interface + */ + masquerade?: object; + /** + * Interface model. One of: e1000, e1000e, ne2k_pci, pcnet, rtl8139, virtio. Defaults to virtio. + * @type {string} + * @memberof V1Interface + */ + model?: string; + /** + * Logical name of the interface as well as a reference to the associated networks. Must match the Name of a Network. + * @type {string} + * @memberof V1Interface + */ + name: string; + /** + * If specified, the virtual network interface will be placed on the guests pci address with the specifed PCI address. For example: 0000:81:01.10 +optional + * @type {string} + * @memberof V1Interface + */ + pciAddress?: string; + /** + * List of ports to be forwarded to the virtual machine. + * @type {Array} + * @memberof V1Interface + */ + ports?: V1Port[]; + /** + * + * @type {object} + * @memberof V1Interface + */ + slirp?: object; + /** + * + * @type {object} + * @memberof V1Interface + */ + sriov?: object; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1KVMTimer.ts b/frontend/packages/kube-types/src/kubevirt/V1KVMTimer.ts new file mode 100644 index 00000000000..e75a7d70acf --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1KVMTimer.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1KVMTimer + */ +export interface V1KVMTimer { + /** + * Enabled set to false makes sure that the machine type or a preset can\'t add the timer. Defaults to true. +optional + * @type {boolean} + * @memberof V1KVMTimer + */ + present?: boolean; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1LabelSelector.ts b/frontend/packages/kube-types/src/kubevirt/V1LabelSelector.ts new file mode 100644 index 00000000000..16c4efb3014 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1LabelSelector.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelectorRequirement } from './V1LabelSelectorRequirement'; + +/** + * A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects. + * @export + * @interface V1LabelSelector + */ +export interface V1LabelSelector { + /** + * matchExpressions is a list of label selector requirements. The requirements are ANDed. + * @type {Array} + * @memberof V1LabelSelector + */ + matchExpressions?: V1LabelSelectorRequirement[]; + /** + * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed. + * @type {object} + * @memberof V1LabelSelector + */ + matchLabels?: object; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1LabelSelectorRequirement.ts b/frontend/packages/kube-types/src/kubevirt/V1LabelSelectorRequirement.ts new file mode 100644 index 00000000000..ae893253677 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1LabelSelectorRequirement.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + * @export + * @interface V1LabelSelectorRequirement + */ +export interface V1LabelSelectorRequirement { + /** + * key is the label key that the selector applies to. + * @type {string} + * @memberof V1LabelSelectorRequirement + */ + key: string; + /** + * operator represents a key\'s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + * @type {string} + * @memberof V1LabelSelectorRequirement + */ + operator: string; + /** + * values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. + * @type {Array} + * @memberof V1LabelSelectorRequirement + */ + values?: string[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1ListMeta.ts b/frontend/packages/kube-types/src/kubevirt/V1ListMeta.ts new file mode 100644 index 00000000000..622d0b3bcaa --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1ListMeta.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}. + * @export + * @interface V1ListMeta + */ +export interface V1ListMeta { + /** + * continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a consistent list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response, unless you have received this token from an error message. + * @type {string} + * @memberof V1ListMeta + */ + _continue?: string; + /** + * String that identifies the server\'s internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency + * @type {string} + * @memberof V1ListMeta + */ + resourceVersion?: string; + /** + * selfLink is a URL representing this object. Populated by the system. Read-only. + * @type {string} + * @memberof V1ListMeta + */ + selfLink?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1LocalObjectReference.ts b/frontend/packages/kube-types/src/kubevirt/V1LocalObjectReference.ts new file mode 100644 index 00000000000..7af7145976b --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1LocalObjectReference.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace. + * @export + * @interface V1LocalObjectReference + */ +export interface V1LocalObjectReference { + /** + * Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1LocalObjectReference + */ + name?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1LunTarget.ts b/frontend/packages/kube-types/src/kubevirt/V1LunTarget.ts new file mode 100644 index 00000000000..4c64cc5b568 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1LunTarget.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1LunTarget + */ +export interface V1LunTarget { + /** + * Bus indicates the type of disk device to emulate. supported values: virtio, sata, scsi. + * @type {string} + * @memberof V1LunTarget + */ + bus?: string; + /** + * ReadOnly. Defaults to false. + * @type {boolean} + * @memberof V1LunTarget + */ + readonly?: boolean; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Machine.ts b/frontend/packages/kube-types/src/kubevirt/V1Machine.ts new file mode 100644 index 00000000000..bbbc32eb441 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Machine.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1Machine + */ +export interface V1Machine { + /** + * QEMU machine type is the actual chipset of the VirtualMachineInstance. + * @type {string} + * @memberof V1Machine + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Memory.ts b/frontend/packages/kube-types/src/kubevirt/V1Memory.ts new file mode 100644 index 00000000000..c02a7dde28d --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Memory.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Hugepages } from './V1Hugepages'; + +/** + * Memory allows specifying the VirtualMachineInstance memory features. + * @export + * @interface V1Memory + */ +export interface V1Memory { + /** + * Guest allows to specifying the amount of memory which is visible inside the Guest OS. The Guest must lie between Requests and Limits from the resources section. Defaults to the requested memory in the resources section if not specified. + optional + * @type {string} + * @memberof V1Memory + */ + guest?: string; + /** + * + * @type {V1Hugepages} + * @memberof V1Memory + */ + hugepages?: V1Hugepages; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1MultusNetwork.ts b/frontend/packages/kube-types/src/kubevirt/V1MultusNetwork.ts new file mode 100644 index 00000000000..781c5893791 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1MultusNetwork.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents the multus cni network. + * @export + * @interface V1MultusNetwork + */ +export interface V1MultusNetwork { + /** + * Select the default network and add it to the multus-cni.io/default-network annotation. + * @type {boolean} + * @memberof V1MultusNetwork + */ + _default?: boolean; + /** + * References to a NetworkAttachmentDefinition CRD object. Format: , /. If namespace is not specified, VMI namespace is assumed. + * @type {string} + * @memberof V1MultusNetwork + */ + networkName: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Network.ts b/frontend/packages/kube-types/src/kubevirt/V1Network.ts new file mode 100644 index 00000000000..59bb3ce8e32 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Network.ts @@ -0,0 +1,48 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1GenieNetwork } from './V1GenieNetwork'; +import { V1MultusNetwork } from './V1MultusNetwork'; +import { V1PodNetwork } from './V1PodNetwork'; + +/** + * Network represents a network type and a resource that should be connected to the vm. + * @export + * @interface V1Network + */ +export interface V1Network { + /** + * + * @type {V1GenieNetwork} + * @memberof V1Network + */ + genie?: V1GenieNetwork; + /** + * + * @type {V1MultusNetwork} + * @memberof V1Network + */ + multus?: V1MultusNetwork; + /** + * Network name. Must be a DNS_LABEL and unique within the vm. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1Network + */ + name: string; + /** + * + * @type {V1PodNetwork} + * @memberof V1Network + */ + pod?: V1PodNetwork; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1NodeAffinity.ts b/frontend/packages/kube-types/src/kubevirt/V1NodeAffinity.ts new file mode 100644 index 00000000000..e70aa9a9835 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1NodeAffinity.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeSelector } from './V1NodeSelector'; +import { V1PreferredSchedulingTerm } from './V1PreferredSchedulingTerm'; + +/** + * Node affinity is a group of node affinity scheduling rules. + * @export + * @interface V1NodeAffinity + */ +export interface V1NodeAffinity { + /** + * The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred. + * @type {Array} + * @memberof V1NodeAffinity + */ + preferredDuringSchedulingIgnoredDuringExecution?: V1PreferredSchedulingTerm[]; + /** + * + * @type {V1NodeSelector} + * @memberof V1NodeAffinity + */ + requiredDuringSchedulingIgnoredDuringExecution?: V1NodeSelector; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1NodeSelector.ts b/frontend/packages/kube-types/src/kubevirt/V1NodeSelector.ts new file mode 100644 index 00000000000..1ce91924937 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1NodeSelector.ts @@ -0,0 +1,28 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeSelectorTerm } from './V1NodeSelectorTerm'; + +/** + * A node selector represents the union of the results of one or more label queries over a set of nodes; that is, it represents the OR of the selectors represented by the node selector terms. + * @export + * @interface V1NodeSelector + */ +export interface V1NodeSelector { + /** + * Required. A list of node selector terms. The terms are ORed. + * @type {Array} + * @memberof V1NodeSelector + */ + nodeSelectorTerms: V1NodeSelectorTerm[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1NodeSelectorRequirement.ts b/frontend/packages/kube-types/src/kubevirt/V1NodeSelectorRequirement.ts new file mode 100644 index 00000000000..818ac622710 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1NodeSelectorRequirement.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values. + * @export + * @interface V1NodeSelectorRequirement + */ +export interface V1NodeSelectorRequirement { + /** + * The label key that the selector applies to. + * @type {string} + * @memberof V1NodeSelectorRequirement + */ + key: string; + /** + * Represents a key\'s relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. + * @type {string} + * @memberof V1NodeSelectorRequirement + */ + operator: string; + /** + * An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. + * @type {Array} + * @memberof V1NodeSelectorRequirement + */ + values?: string[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1NodeSelectorTerm.ts b/frontend/packages/kube-types/src/kubevirt/V1NodeSelectorTerm.ts new file mode 100644 index 00000000000..8d43558949a --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1NodeSelectorTerm.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeSelectorRequirement } from './V1NodeSelectorRequirement'; + +/** + * A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm. + * @export + * @interface V1NodeSelectorTerm + */ +export interface V1NodeSelectorTerm { + /** + * A list of node selector requirements by node\'s labels. + * @type {Array} + * @memberof V1NodeSelectorTerm + */ + matchExpressions?: V1NodeSelectorRequirement[]; + /** + * A list of node selector requirements by node\'s fields. + * @type {Array} + * @memberof V1NodeSelectorTerm + */ + matchFields?: V1NodeSelectorRequirement[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1ObjectMeta.ts b/frontend/packages/kube-types/src/kubevirt/V1ObjectMeta.ts new file mode 100644 index 00000000000..c5ab19d5f05 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1ObjectMeta.ts @@ -0,0 +1,113 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Initializers } from './V1Initializers'; +import { V1OwnerReference } from './V1OwnerReference'; + +/** + * ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create. + * @export + * @interface V1ObjectMeta + */ +export interface V1ObjectMeta { + /** + * Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations + * @type {object} + * @memberof V1ObjectMeta + */ + annotations?: object; + /** + * The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request. + * @type {string} + * @memberof V1ObjectMeta + */ + clusterName?: string; + /** + * Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only. + * @type {number} + * @memberof V1ObjectMeta + */ + deletionGracePeriodSeconds?: number; + /** + * DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested. Populated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata + * @type {string} + * @memberof V1ObjectMeta + */ + deletionTimestamp?: string; + /** + * Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. + * @type {Array} + * @memberof V1ObjectMeta + */ + finalizers?: string[]; + /** + * GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server. If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header). Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#idempotency + * @type {string} + * @memberof V1ObjectMeta + */ + generateName?: string; + /** + * A sequence number representing a specific generation of the desired state. Populated by the system. Read-only. + * @type {number} + * @memberof V1ObjectMeta + */ + generation?: number; + /** + * + * @type {V1Initializers} + * @memberof V1ObjectMeta + */ + initializers?: V1Initializers; + /** + * Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels + * @type {object} + * @memberof V1ObjectMeta + */ + labels?: object; + /** + * Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names + * @type {string} + * @memberof V1ObjectMeta + */ + name?: string; + /** + * Namespace defines the space within each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces + * @type {string} + * @memberof V1ObjectMeta + */ + namespace?: string; + /** + * List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller. + * @type {Array} + * @memberof V1ObjectMeta + */ + ownerReferences?: V1OwnerReference[]; + /** + * An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources. Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency + * @type {string} + * @memberof V1ObjectMeta + */ + resourceVersion?: string; + /** + * SelfLink is a URL representing this object. Populated by the system. Read-only. + * @type {string} + * @memberof V1ObjectMeta + */ + selfLink?: string; + /** + * UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations. Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids + * @type {string} + * @memberof V1ObjectMeta + */ + uid?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1OwnerReference.ts b/frontend/packages/kube-types/src/kubevirt/V1OwnerReference.ts new file mode 100644 index 00000000000..29838e3358c --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1OwnerReference.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * OwnerReference contains enough information to let you identify an owning object. An owning object must be in the same namespace as the dependent, or be cluster-scoped, so there is no namespace field. + * @export + * @interface V1OwnerReference + */ +export interface V1OwnerReference { + /** + * API version of the referent. + * @type {string} + * @memberof V1OwnerReference + */ + apiVersion: string; + /** + * If true, AND if the owner has the \"foregroundDeletion\" finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs \"delete\" permission of the owner, otherwise 422 (Unprocessable Entity) will be returned. + * @type {boolean} + * @memberof V1OwnerReference + */ + blockOwnerDeletion?: boolean; + /** + * If true, this reference points to the managing controller. + * @type {boolean} + * @memberof V1OwnerReference + */ + controller?: boolean; + /** + * Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1OwnerReference + */ + kind: string; + /** + * Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names + * @type {string} + * @memberof V1OwnerReference + */ + name: string; + /** + * UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids + * @type {string} + * @memberof V1OwnerReference + */ + uid: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1PITTimer.ts b/frontend/packages/kube-types/src/kubevirt/V1PITTimer.ts new file mode 100644 index 00000000000..a2e4224de5c --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1PITTimer.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1PITTimer + */ +export interface V1PITTimer { + /** + * Enabled set to false makes sure that the machine type or a preset can\'t add the timer. Defaults to true. +optional + * @type {boolean} + * @memberof V1PITTimer + */ + present?: boolean; + /** + * TickPolicy determines what happens when QEMU misses a deadline for injecting a tick to the guest. One of \"delay\", \"catchup\", \"discard\". + * @type {string} + * @memberof V1PITTimer + */ + tickPolicy?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1PersistentVolumeClaimSpec.ts b/frontend/packages/kube-types/src/kubevirt/V1PersistentVolumeClaimSpec.ts new file mode 100644 index 00000000000..89100dc8caa --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1PersistentVolumeClaimSpec.ts @@ -0,0 +1,66 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; +import { V1ResourceRequirements } from './V1ResourceRequirements'; +import { V1TypedLocalObjectReference } from './V1TypedLocalObjectReference'; + +/** + * PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes + * @export + * @interface V1PersistentVolumeClaimSpec + */ +export interface V1PersistentVolumeClaimSpec { + /** + * AccessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 + * @type {Array} + * @memberof V1PersistentVolumeClaimSpec + */ + accessModes?: object[]; + /** + * + * @type {V1TypedLocalObjectReference} + * @memberof V1PersistentVolumeClaimSpec + */ + dataSource?: V1TypedLocalObjectReference; + /** + * + * @type {V1ResourceRequirements} + * @memberof V1PersistentVolumeClaimSpec + */ + resources?: V1ResourceRequirements; + /** + * + * @type {V1LabelSelector} + * @memberof V1PersistentVolumeClaimSpec + */ + selector?: V1LabelSelector; + /** + * Name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1 + * @type {string} + * @memberof V1PersistentVolumeClaimSpec + */ + storageClassName?: string; + /** + * + * @type {object} + * @memberof V1PersistentVolumeClaimSpec + */ + volumeMode?: object; + /** + * VolumeName is the binding reference to the PersistentVolume backing this claim. + * @type {string} + * @memberof V1PersistentVolumeClaimSpec + */ + volumeName?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1PersistentVolumeClaimVolumeSource.ts b/frontend/packages/kube-types/src/kubevirt/V1PersistentVolumeClaimVolumeSource.ts new file mode 100644 index 00000000000..52009b75fc2 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1PersistentVolumeClaimVolumeSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PersistentVolumeClaimVolumeSource references the user\'s PVC in the same namespace. This volume finds the bound PV and mounts that volume for the pod. A PersistentVolumeClaimVolumeSource is, essentially, a wrapper around another type of volume that is owned by someone else (the system). + * @export + * @interface V1PersistentVolumeClaimVolumeSource + */ +export interface V1PersistentVolumeClaimVolumeSource { + /** + * ClaimName is the name of a PersistentVolumeClaim in the same namespace as the pod using this volume. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims + * @type {string} + * @memberof V1PersistentVolumeClaimVolumeSource + */ + claimName: string; + /** + * Will force the ReadOnly setting in VolumeMounts. Default false. + * @type {boolean} + * @memberof V1PersistentVolumeClaimVolumeSource + */ + readOnly?: boolean; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1PodAffinity.ts b/frontend/packages/kube-types/src/kubevirt/V1PodAffinity.ts new file mode 100644 index 00000000000..0e2d5dc6ae6 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1PodAffinity.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodAffinityTerm } from './V1PodAffinityTerm'; +import { V1WeightedPodAffinityTerm } from './V1WeightedPodAffinityTerm'; + +/** + * Pod affinity is a group of inter pod affinity scheduling rules. + * @export + * @interface V1PodAffinity + */ +export interface V1PodAffinity { + /** + * The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + * @type {Array} + * @memberof V1PodAffinity + */ + preferredDuringSchedulingIgnoredDuringExecution?: V1WeightedPodAffinityTerm[]; + /** + * If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + * @type {Array} + * @memberof V1PodAffinity + */ + requiredDuringSchedulingIgnoredDuringExecution?: V1PodAffinityTerm[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1PodAffinityTerm.ts b/frontend/packages/kube-types/src/kubevirt/V1PodAffinityTerm.ts new file mode 100644 index 00000000000..b5a994c4796 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1PodAffinityTerm.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key matches that of any node on which a pod of the set of pods is running + * @export + * @interface V1PodAffinityTerm + */ +export interface V1PodAffinityTerm { + /** + * + * @type {V1LabelSelector} + * @memberof V1PodAffinityTerm + */ + labelSelector?: V1LabelSelector; + /** + * namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means \"this pod\'s namespace\" + * @type {Array} + * @memberof V1PodAffinityTerm + */ + namespaces?: string[]; + /** + * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. + * @type {string} + * @memberof V1PodAffinityTerm + */ + topologyKey: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1PodAntiAffinity.ts b/frontend/packages/kube-types/src/kubevirt/V1PodAntiAffinity.ts new file mode 100644 index 00000000000..0d3c9ca2a53 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1PodAntiAffinity.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodAffinityTerm } from './V1PodAffinityTerm'; +import { V1WeightedPodAffinityTerm } from './V1WeightedPodAffinityTerm'; + +/** + * Pod anti affinity is a group of inter pod anti affinity scheduling rules. + * @export + * @interface V1PodAntiAffinity + */ +export interface V1PodAntiAffinity { + /** + * The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding \"weight\" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. + * @type {Array} + * @memberof V1PodAntiAffinity + */ + preferredDuringSchedulingIgnoredDuringExecution?: V1WeightedPodAffinityTerm[]; + /** + * If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. + * @type {Array} + * @memberof V1PodAntiAffinity + */ + requiredDuringSchedulingIgnoredDuringExecution?: V1PodAffinityTerm[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1PodDNSConfig.ts b/frontend/packages/kube-types/src/kubevirt/V1PodDNSConfig.ts new file mode 100644 index 00000000000..8dca934a342 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1PodDNSConfig.ts @@ -0,0 +1,40 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodDNSConfigOption } from './V1PodDNSConfigOption'; + +/** + * PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy. + * @export + * @interface V1PodDNSConfig + */ +export interface V1PodDNSConfig { + /** + * A list of DNS name server IP addresses. This will be appended to the base nameservers generated from DNSPolicy. Duplicated nameservers will be removed. + * @type {Array} + * @memberof V1PodDNSConfig + */ + nameservers?: string[]; + /** + * A list of DNS resolver options. This will be merged with the base options generated from DNSPolicy. Duplicated entries will be removed. Resolution options given in Options will override those that appear in the base DNSPolicy. + * @type {Array} + * @memberof V1PodDNSConfig + */ + options?: V1PodDNSConfigOption[]; + /** + * A list of DNS search domains for host-name lookup. This will be appended to the base search paths generated from DNSPolicy. Duplicated search paths will be removed. + * @type {Array} + * @memberof V1PodDNSConfig + */ + searches?: string[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1PodDNSConfigOption.ts b/frontend/packages/kube-types/src/kubevirt/V1PodDNSConfigOption.ts new file mode 100644 index 00000000000..23cf0cebe5b --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1PodDNSConfigOption.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * PodDNSConfigOption defines DNS resolver options of a pod. + * @export + * @interface V1PodDNSConfigOption + */ +export interface V1PodDNSConfigOption { + /** + * Required. + * @type {string} + * @memberof V1PodDNSConfigOption + */ + name?: string; + /** + * + * @type {string} + * @memberof V1PodDNSConfigOption + */ + value?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1PodNetwork.ts b/frontend/packages/kube-types/src/kubevirt/V1PodNetwork.ts new file mode 100644 index 00000000000..10f4795a149 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1PodNetwork.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Represents the stock pod network interface. + * @export + * @interface V1PodNetwork + */ +export interface V1PodNetwork { + /** + * CIDR for vm network. Default 10.0.2.0/24 if not specified. + * @type {string} + * @memberof V1PodNetwork + */ + vmNetworkCIDR?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Port.ts b/frontend/packages/kube-types/src/kubevirt/V1Port.ts new file mode 100644 index 00000000000..4fd5861119a --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Port.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Port repesents a port to expose from the virtual machine. Default protocol TCP. The port field is mandatory + * @export + * @interface V1Port + */ +export interface V1Port { + /** + * If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services. +optional + * @type {string} + * @memberof V1Port + */ + name?: string; + /** + * Number of port to expose for the virtual machine. This must be a valid port number, 0 < x < 65536. + * @type {number} + * @memberof V1Port + */ + port: number; + /** + * Protocol for port. Must be UDP or TCP. Defaults to \"TCP\". +optional + * @type {string} + * @memberof V1Port + */ + protocol?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Preconditions.ts b/frontend/packages/kube-types/src/kubevirt/V1Preconditions.ts new file mode 100644 index 00000000000..e026c94a2e6 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Preconditions.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out. + * @export + * @interface V1Preconditions + */ +export interface V1Preconditions { + /** + * + * @type {object} + * @memberof V1Preconditions + */ + uid?: object; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1PreferredSchedulingTerm.ts b/frontend/packages/kube-types/src/kubevirt/V1PreferredSchedulingTerm.ts new file mode 100644 index 00000000000..c9048a9addc --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1PreferredSchedulingTerm.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1NodeSelectorTerm } from './V1NodeSelectorTerm'; + +/** + * An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it\'s a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op). + * @export + * @interface V1PreferredSchedulingTerm + */ +export interface V1PreferredSchedulingTerm { + /** + * + * @type {V1NodeSelectorTerm} + * @memberof V1PreferredSchedulingTerm + */ + preference: V1NodeSelectorTerm; + /** + * Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100. + * @type {number} + * @memberof V1PreferredSchedulingTerm + */ + weight: number; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Probe.ts b/frontend/packages/kube-types/src/kubevirt/V1Probe.ts new file mode 100644 index 00000000000..ed680eb9646 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Probe.ts @@ -0,0 +1,65 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1HTTPGetAction } from './V1HTTPGetAction'; +import { V1TCPSocketAction } from './V1TCPSocketAction'; + +/** + * Probe describes a health check to be performed against a VirtualMachineInstance to determine whether it is alive or ready to receive traffic. + * @export + * @interface V1Probe + */ +export interface V1Probe { + /** + * Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1. +optional + * @type {number} + * @memberof V1Probe + */ + failureThreshold?: number; + /** + * + * @type {V1HTTPGetAction} + * @memberof V1Probe + */ + httpGet?: V1HTTPGetAction; + /** + * Number of seconds after the VirtualMachineInstance has started before liveness probes are initiated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +optional + * @type {number} + * @memberof V1Probe + */ + initialDelaySeconds?: number; + /** + * How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. +optional + * @type {number} + * @memberof V1Probe + */ + periodSeconds?: number; + /** + * Minimum consecutive successes for the probe to be considered successful after having failed. Defaults to 1. Must be 1 for liveness. Minimum value is 1. +optional + * @type {number} + * @memberof V1Probe + */ + successThreshold?: number; + /** + * + * @type {V1TCPSocketAction} + * @memberof V1Probe + */ + tcpSocket?: V1TCPSocketAction; + /** + * Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes +optional + * @type {number} + * @memberof V1Probe + */ + timeoutSeconds?: number; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1RTCTimer.ts b/frontend/packages/kube-types/src/kubevirt/V1RTCTimer.ts new file mode 100644 index 00000000000..79ed93e1c85 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1RTCTimer.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1RTCTimer + */ +export interface V1RTCTimer { + /** + * Enabled set to false makes sure that the machine type or a preset can\'t add the timer. Defaults to true. +optional + * @type {boolean} + * @memberof V1RTCTimer + */ + present?: boolean; + /** + * TickPolicy determines what happens when QEMU misses a deadline for injecting a tick to the guest. One of \"delay\", \"catchup\". + * @type {string} + * @memberof V1RTCTimer + */ + tickPolicy?: string; + /** + * Track the guest or the wall clock. + * @type {string} + * @memberof V1RTCTimer + */ + track?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1ResourceRequirements.ts b/frontend/packages/kube-types/src/kubevirt/V1ResourceRequirements.ts new file mode 100644 index 00000000000..b2f18b4fe31 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1ResourceRequirements.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1ResourceRequirements + */ +export interface V1ResourceRequirements { + /** + * Limits describes the maximum amount of compute resources allowed. Valid resource keys are \"memory\" and \"cpu\". +optional + * @type {object} + * @memberof V1ResourceRequirements + */ + limits?: object; + /** + * Don\'t ask the scheduler to take the guest-management overhead into account. Instead put the overhead only into the container\'s memory limit. This can lead to crashes if all memory is in use on a node. Defaults to false. + * @type {boolean} + * @memberof V1ResourceRequirements + */ + overcommitGuestOverhead?: boolean; + /** + * Requests is a description of the initial vmi resources. Valid resource keys are \"memory\" and \"cpu\". +optional + * @type {object} + * @memberof V1ResourceRequirements + */ + requests?: object; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1RootPaths.ts b/frontend/packages/kube-types/src/kubevirt/V1RootPaths.ts new file mode 100644 index 00000000000..9f50ec0cbae --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1RootPaths.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * RootPaths lists the paths available at root. For example: \"/healthz\", \"/apis\". + * @export + * @interface V1RootPaths + */ +export interface V1RootPaths { + /** + * paths are the paths available at root. + * @type {Array} + * @memberof V1RootPaths + */ + paths: string[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1SecretVolumeSource.ts b/frontend/packages/kube-types/src/kubevirt/V1SecretVolumeSource.ts new file mode 100644 index 00000000000..f23ee5ad78c --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1SecretVolumeSource.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * SecretVolumeSource adapts a Secret into a volume. + * @export + * @interface V1SecretVolumeSource + */ +export interface V1SecretVolumeSource { + /** + * Specify whether the Secret or it\'s keys must be defined +optional + * @type {boolean} + * @memberof V1SecretVolumeSource + */ + optional?: boolean; + /** + * Name of the secret in the pod\'s namespace to use. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret +optional + * @type {string} + * @memberof V1SecretVolumeSource + */ + secretName?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1ServerAddressByClientCIDR.ts b/frontend/packages/kube-types/src/kubevirt/V1ServerAddressByClientCIDR.ts new file mode 100644 index 00000000000..f844e31d311 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1ServerAddressByClientCIDR.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match. + * @export + * @interface V1ServerAddressByClientCIDR + */ +export interface V1ServerAddressByClientCIDR { + /** + * The CIDR with which clients can match their IP to figure out the server address that they should use. + * @type {string} + * @memberof V1ServerAddressByClientCIDR + */ + clientCIDR: string; + /** + * Address of this server, suitable for a client that matches the above CIDR. This can be a hostname, hostname:port, IP or IP:port. + * @type {string} + * @memberof V1ServerAddressByClientCIDR + */ + serverAddress: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1ServiceAccountVolumeSource.ts b/frontend/packages/kube-types/src/kubevirt/V1ServiceAccountVolumeSource.ts new file mode 100644 index 00000000000..bedfd0c5a98 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1ServiceAccountVolumeSource.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * ServiceAccountVolumeSource adapts a ServiceAccount into a volume. + * @export + * @interface V1ServiceAccountVolumeSource + */ +export interface V1ServiceAccountVolumeSource { + /** + * Name of the service account in the pod\'s namespace to use. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/ + * @type {string} + * @memberof V1ServiceAccountVolumeSource + */ + serviceAccountName?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Status.ts b/frontend/packages/kube-types/src/kubevirt/V1Status.ts new file mode 100644 index 00000000000..e6f32857165 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Status.ts @@ -0,0 +1,71 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ListMeta } from './V1ListMeta'; +import { V1StatusDetails } from './V1StatusDetails'; + +/** + * Status is a return value for calls that don\'t return other objects. + * @export + * @interface V1Status + */ +export interface V1Status { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1Status + */ + apiVersion?: string; + /** + * Suggested HTTP return code for this status, 0 if not set. + * @type {number} + * @memberof V1Status + */ + code?: number; + /** + * + * @type {V1StatusDetails} + * @memberof V1Status + */ + details?: V1StatusDetails; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1Status + */ + kind?: string; + /** + * A human-readable description of the status of this operation. + * @type {string} + * @memberof V1Status + */ + message?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1Status + */ + metadata?: V1ListMeta; + /** + * A machine-readable description of why this operation is in the \"Failure\" status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it. + * @type {string} + * @memberof V1Status + */ + reason?: string; + /** + * Status of the operation. One of: \"Success\" or \"Failure\". More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status + * @type {string} + * @memberof V1Status + */ + status?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1StatusCause.ts b/frontend/packages/kube-types/src/kubevirt/V1StatusCause.ts new file mode 100644 index 00000000000..c1b297fd8e5 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1StatusCause.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered. + * @export + * @interface V1StatusCause + */ +export interface V1StatusCause { + /** + * The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed. Fields may appear more than once in an array of causes due to fields having multiple errors. Optional. Examples: \"name\" - the field \"name\" on the current resource \"items[0].name\" - the field \"name\" on the first array entry in \"items\" + * @type {string} + * @memberof V1StatusCause + */ + field?: string; + /** + * A human-readable description of the cause of the error. This field may be presented as-is to a reader. + * @type {string} + * @memberof V1StatusCause + */ + message?: string; + /** + * A machine-readable description of the cause of the error. If this value is empty there is no information available. + * @type {string} + * @memberof V1StatusCause + */ + reason?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1StatusDetails.ts b/frontend/packages/kube-types/src/kubevirt/V1StatusDetails.ts new file mode 100644 index 00000000000..917d6b4d68a --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1StatusDetails.ts @@ -0,0 +1,58 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1StatusCause } from './V1StatusCause'; + +/** + * StatusDetails is a set of additional properties that MAY be set by the server to provide additional information about a response. The Reason field of a Status object defines what attributes will be set. Clients must ignore fields that do not match the defined type of each attribute, and should assume that any attribute may be empty, invalid, or under defined. + * @export + * @interface V1StatusDetails + */ +export interface V1StatusDetails { + /** + * The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes. + * @type {Array} + * @memberof V1StatusDetails + */ + causes?: V1StatusCause[]; + /** + * The group attribute of the resource associated with the status StatusReason. + * @type {string} + * @memberof V1StatusDetails + */ + group?: string; + /** + * The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1StatusDetails + */ + kind?: string; + /** + * The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described). + * @type {string} + * @memberof V1StatusDetails + */ + name?: string; + /** + * If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action. + * @type {number} + * @memberof V1StatusDetails + */ + retryAfterSeconds?: number; + /** + * UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids + * @type {string} + * @memberof V1StatusDetails + */ + uid?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1TCPSocketAction.ts b/frontend/packages/kube-types/src/kubevirt/V1TCPSocketAction.ts new file mode 100644 index 00000000000..9202cb11266 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1TCPSocketAction.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TCPSocketAction describes an action based on opening a socket + * @export + * @interface V1TCPSocketAction + */ +export interface V1TCPSocketAction { + /** + * Optional: Host name to connect to, defaults to the pod IP. + * @type {string} + * @memberof V1TCPSocketAction + */ + host?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Timer.ts b/frontend/packages/kube-types/src/kubevirt/V1Timer.ts new file mode 100644 index 00000000000..872f999e88c --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Timer.ts @@ -0,0 +1,56 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1HPETTimer } from './V1HPETTimer'; +import { V1HypervTimer } from './V1HypervTimer'; +import { V1KVMTimer } from './V1KVMTimer'; +import { V1PITTimer } from './V1PITTimer'; +import { V1RTCTimer } from './V1RTCTimer'; + +/** + * Represents all available timers in a vmi. + * @export + * @interface V1Timer + */ +export interface V1Timer { + /** + * + * @type {V1HPETTimer} + * @memberof V1Timer + */ + hpet?: V1HPETTimer; + /** + * + * @type {V1HypervTimer} + * @memberof V1Timer + */ + hyperv?: V1HypervTimer; + /** + * + * @type {V1KVMTimer} + * @memberof V1Timer + */ + kvm?: V1KVMTimer; + /** + * + * @type {V1PITTimer} + * @memberof V1Timer + */ + pit?: V1PITTimer; + /** + * + * @type {V1RTCTimer} + * @memberof V1Timer + */ + rtc?: V1RTCTimer; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Toleration.ts b/frontend/packages/kube-types/src/kubevirt/V1Toleration.ts new file mode 100644 index 00000000000..fcb2ac5d686 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Toleration.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator . + * @export + * @interface V1Toleration + */ +export interface V1Toleration { + /** + * Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute. + * @type {string} + * @memberof V1Toleration + */ + effect?: string; + /** + * Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. + * @type {string} + * @memberof V1Toleration + */ + key?: string; + /** + * Operator represents a key\'s relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all taints of a particular category. + * @type {string} + * @memberof V1Toleration + */ + operator?: string; + /** + * TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. + * @type {number} + * @memberof V1Toleration + */ + tolerationSeconds?: number; + /** + * Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string. + * @type {string} + * @memberof V1Toleration + */ + value?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1TypedLocalObjectReference.ts b/frontend/packages/kube-types/src/kubevirt/V1TypedLocalObjectReference.ts new file mode 100644 index 00000000000..1c80d4b0ef0 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1TypedLocalObjectReference.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace. + * @export + * @interface V1TypedLocalObjectReference + */ +export interface V1TypedLocalObjectReference { + /** + * APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. + * @type {string} + * @memberof V1TypedLocalObjectReference + */ + apiGroup: string; + /** + * Kind is the type of resource being referenced + * @type {string} + * @memberof V1TypedLocalObjectReference + */ + kind: string; + /** + * Name is the name of resource being referenced + * @type {string} + * @memberof V1TypedLocalObjectReference + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachine.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachine.ts new file mode 100644 index 00000000000..0a1fd4d6135 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachine.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { V1VirtualMachineSpec } from './V1VirtualMachineSpec'; +import { V1VirtualMachineStatus } from './V1VirtualMachineStatus'; + +/** + * VirtualMachine handles the VirtualMachines that are not running or are in a stopped state The VirtualMachine contains the template to create the VirtualMachineInstance. It also mirrors the running state of the created VirtualMachineInstance in its status. + * @export + * @interface V1VirtualMachine + */ +export interface V1VirtualMachine { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1VirtualMachine + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1VirtualMachine + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1VirtualMachine + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1VirtualMachineSpec} + * @memberof V1VirtualMachine + */ + spec?: V1VirtualMachineSpec; + /** + * + * @type {V1VirtualMachineStatus} + * @memberof V1VirtualMachine + */ + status?: V1VirtualMachineStatus; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineCondition.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineCondition.ts new file mode 100644 index 00000000000..58e4881a5ef --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineCondition.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * VirtualMachineCondition represents the state of VirtualMachine + * @export + * @interface V1VirtualMachineCondition + */ +export interface V1VirtualMachineCondition { + /** + * + * @type {string} + * @memberof V1VirtualMachineCondition + */ + message?: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineCondition + */ + reason?: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineCondition + */ + status: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstance.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstance.ts new file mode 100644 index 00000000000..e48eea4b242 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstance.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { V1VirtualMachineInstanceSpec } from './V1VirtualMachineInstanceSpec'; +import { V1VirtualMachineInstanceStatus } from './V1VirtualMachineInstanceStatus'; + +/** + * VirtualMachineInstance is *the* VirtualMachineInstance Definition. It represents a virtual machine in the runtime environment of kubernetes. + * @export + * @interface V1VirtualMachineInstance + */ +export interface V1VirtualMachineInstance { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1VirtualMachineInstance + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1VirtualMachineInstance + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1VirtualMachineInstance + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1VirtualMachineInstanceSpec} + * @memberof V1VirtualMachineInstance + */ + spec?: V1VirtualMachineInstanceSpec; + /** + * + * @type {V1VirtualMachineInstanceStatus} + * @memberof V1VirtualMachineInstance + */ + status?: V1VirtualMachineInstanceStatus; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceCondition.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceCondition.ts new file mode 100644 index 00000000000..7c8d39ba261 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceCondition.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1VirtualMachineInstanceCondition + */ +export interface V1VirtualMachineInstanceCondition { + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceCondition + */ + message?: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceCondition + */ + reason?: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceCondition + */ + status: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceList.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceList.ts new file mode 100644 index 00000000000..ca1c64531e1 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ListMeta } from './V1ListMeta'; +import { V1VirtualMachineInstance } from './V1VirtualMachineInstance'; + +/** + * VirtualMachineInstanceList is a list of VirtualMachines + * @export + * @interface V1VirtualMachineInstanceList + */ +export interface V1VirtualMachineInstanceList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1VirtualMachineInstanceList + */ + apiVersion?: string; + /** + * + * @type {Array} + * @memberof V1VirtualMachineInstanceList + */ + items: V1VirtualMachineInstance[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1VirtualMachineInstanceList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1VirtualMachineInstanceList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigration.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigration.ts new file mode 100644 index 00000000000..f8ea3d164ae --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigration.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { V1VirtualMachineInstanceMigrationSpec } from './V1VirtualMachineInstanceMigrationSpec'; +import { V1VirtualMachineInstanceMigrationStatus } from './V1VirtualMachineInstanceMigrationStatus'; + +/** + * VirtualMachineInstanceMigration represents the object tracking a VMI\'s migration to another host in the cluster + * @export + * @interface V1VirtualMachineInstanceMigration + */ +export interface V1VirtualMachineInstanceMigration { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1VirtualMachineInstanceMigration + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1VirtualMachineInstanceMigration + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1VirtualMachineInstanceMigration + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1VirtualMachineInstanceMigrationSpec} + * @memberof V1VirtualMachineInstanceMigration + */ + spec?: V1VirtualMachineInstanceMigrationSpec; + /** + * + * @type {V1VirtualMachineInstanceMigrationStatus} + * @memberof V1VirtualMachineInstanceMigration + */ + status?: V1VirtualMachineInstanceMigrationStatus; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationCondition.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationCondition.ts new file mode 100644 index 00000000000..501507add10 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationCondition.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1VirtualMachineInstanceMigrationCondition + */ +export interface V1VirtualMachineInstanceMigrationCondition { + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationCondition + */ + message?: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationCondition + */ + reason?: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationCondition + */ + status: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationList.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationList.ts new file mode 100644 index 00000000000..7cccb327ab5 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ListMeta } from './V1ListMeta'; +import { V1VirtualMachineInstanceMigration } from './V1VirtualMachineInstanceMigration'; + +/** + * VirtualMachineInstanceMigrationList is a list of VirtualMachineMigrations + * @export + * @interface V1VirtualMachineInstanceMigrationList + */ +export interface V1VirtualMachineInstanceMigrationList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationList + */ + apiVersion?: string; + /** + * + * @type {Array} + * @memberof V1VirtualMachineInstanceMigrationList + */ + items: V1VirtualMachineInstanceMigration[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1VirtualMachineInstanceMigrationList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationSpec.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationSpec.ts new file mode 100644 index 00000000000..218aa40d338 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationSpec.ts @@ -0,0 +1,26 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1VirtualMachineInstanceMigrationSpec + */ +export interface V1VirtualMachineInstanceMigrationSpec { + /** + * The name of the VMI to perform the migration on. VMI must exist in the migration objects namespace + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationSpec + */ + vmiName?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationState.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationState.ts new file mode 100644 index 00000000000..aa0f81e9a5c --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationState.ts @@ -0,0 +1,98 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1VirtualMachineInstanceMigrationState + */ +export interface V1VirtualMachineInstanceMigrationState { + /** + * Indicates that the migration has been requested to abort + * @type {boolean} + * @memberof V1VirtualMachineInstanceMigrationState + */ + abortRequested?: boolean; + /** + * Indicates the final status of the live migration abortion + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationState + */ + abortStatus?: string; + /** + * Indicates the migration completed + * @type {boolean} + * @memberof V1VirtualMachineInstanceMigrationState + */ + completed?: boolean; + /** + * The time the migration action ended + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationState + */ + endTimestamp?: string; + /** + * Indicates that the migration failed + * @type {boolean} + * @memberof V1VirtualMachineInstanceMigrationState + */ + failed?: boolean; + /** + * The VirtualMachineInstanceMigration object associated with this migration + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationState + */ + migrationUid?: string; + /** + * The source node that the VMI originated on + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationState + */ + sourceNode?: string; + /** + * The time the migration action began + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationState + */ + startTimestamp?: string; + /** + * The list of ports opened for live migration on the destination node + * @type {object} + * @memberof V1VirtualMachineInstanceMigrationState + */ + targetDirectMigrationNodePorts?: object; + /** + * The target node that the VMI is moving to + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationState + */ + targetNode?: string; + /** + * The address of the target node to use for the migration + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationState + */ + targetNodeAddress?: string; + /** + * The Target Node has seen the Domain Start Event + * @type {boolean} + * @memberof V1VirtualMachineInstanceMigrationState + */ + targetNodeDomainDetected?: boolean; + /** + * The target pod that the VMI is moving to + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationState + */ + targetPod?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationStatus.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationStatus.ts new file mode 100644 index 00000000000..443005868f7 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceMigrationStatus.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1VirtualMachineInstanceMigrationCondition } from './V1VirtualMachineInstanceMigrationCondition'; + +/** + * VirtualMachineInstanceMigration reprents information pertaining to a VMI\'s migration. + * @export + * @interface V1VirtualMachineInstanceMigrationStatus + */ +export interface V1VirtualMachineInstanceMigrationStatus { + /** + * + * @type {Array} + * @memberof V1VirtualMachineInstanceMigrationStatus + */ + conditions?: V1VirtualMachineInstanceMigrationCondition[]; + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceMigrationStatus + */ + phase?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceNetworkInterface.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceNetworkInterface.ts new file mode 100644 index 00000000000..043d0214044 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceNetworkInterface.ts @@ -0,0 +1,50 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1VirtualMachineInstanceNetworkInterface + */ +export interface V1VirtualMachineInstanceNetworkInterface { + /** + * The interface name inside the Virtual Machine + * @type {string} + * @memberof V1VirtualMachineInstanceNetworkInterface + */ + interfaceName?: string; + /** + * IP address of a Virtual Machine interface + * @type {string} + * @memberof V1VirtualMachineInstanceNetworkInterface + */ + ipAddress?: string; + /** + * List of all IP addresses of a Virtual Machine interface + * @type {Array} + * @memberof V1VirtualMachineInstanceNetworkInterface + */ + ipAddresses?: string[]; + /** + * Hardware address of a Virtual Machine interface + * @type {string} + * @memberof V1VirtualMachineInstanceNetworkInterface + */ + mac?: string; + /** + * Name of the interface, corresponds to name of the network assigned to the interface + * @type {string} + * @memberof V1VirtualMachineInstanceNetworkInterface + */ + name?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePreset.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePreset.ts new file mode 100644 index 00000000000..465aa497432 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePreset.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { V1VirtualMachineInstancePresetSpec } from './V1VirtualMachineInstancePresetSpec'; + +/** + * + * @export + * @interface V1VirtualMachineInstancePreset + */ +export interface V1VirtualMachineInstancePreset { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1VirtualMachineInstancePreset + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1VirtualMachineInstancePreset + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1VirtualMachineInstancePreset + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1VirtualMachineInstancePresetSpec} + * @memberof V1VirtualMachineInstancePreset + */ + spec?: V1VirtualMachineInstancePresetSpec; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePresetList.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePresetList.ts new file mode 100644 index 00000000000..0141b886629 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePresetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ListMeta } from './V1ListMeta'; +import { V1VirtualMachineInstancePreset } from './V1VirtualMachineInstancePreset'; + +/** + * VirtualMachineInstancePresetList is a list of VirtualMachinePresets + * @export + * @interface V1VirtualMachineInstancePresetList + */ +export interface V1VirtualMachineInstancePresetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1VirtualMachineInstancePresetList + */ + apiVersion?: string; + /** + * + * @type {Array} + * @memberof V1VirtualMachineInstancePresetList + */ + items: V1VirtualMachineInstancePreset[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1VirtualMachineInstancePresetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1VirtualMachineInstancePresetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePresetSpec.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePresetSpec.ts new file mode 100644 index 00000000000..622a08b511a --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstancePresetSpec.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1DomainSpec } from './V1DomainSpec'; +import { V1LabelSelector } from './V1LabelSelector'; + +/** + * + * @export + * @interface V1VirtualMachineInstancePresetSpec + */ +export interface V1VirtualMachineInstancePresetSpec { + /** + * + * @type {V1DomainSpec} + * @memberof V1VirtualMachineInstancePresetSpec + */ + domain?: V1DomainSpec; + /** + * + * @type {V1LabelSelector} + * @memberof V1VirtualMachineInstancePresetSpec + */ + selector: V1LabelSelector; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSet.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSet.ts new file mode 100644 index 00000000000..2ac6e120a00 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSet.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { V1VirtualMachineInstanceReplicaSetSpec } from './V1VirtualMachineInstanceReplicaSetSpec'; +import { V1VirtualMachineInstanceReplicaSetStatus } from './V1VirtualMachineInstanceReplicaSetStatus'; + +/** + * VirtualMachineInstance is *the* VirtualMachineInstance Definition. It represents a virtual machine in the runtime environment of kubernetes. + * @export + * @interface V1VirtualMachineInstanceReplicaSet + */ +export interface V1VirtualMachineInstanceReplicaSet { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1VirtualMachineInstanceReplicaSet + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1VirtualMachineInstanceReplicaSet + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1VirtualMachineInstanceReplicaSet + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1VirtualMachineInstanceReplicaSetSpec} + * @memberof V1VirtualMachineInstanceReplicaSet + */ + spec?: V1VirtualMachineInstanceReplicaSetSpec; + /** + * + * @type {V1VirtualMachineInstanceReplicaSetStatus} + * @memberof V1VirtualMachineInstanceReplicaSet + */ + status?: V1VirtualMachineInstanceReplicaSetStatus; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetCondition.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetCondition.ts new file mode 100644 index 00000000000..5cdf4595040 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetCondition.ts @@ -0,0 +1,44 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1VirtualMachineInstanceReplicaSetCondition + */ +export interface V1VirtualMachineInstanceReplicaSetCondition { + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceReplicaSetCondition + */ + message?: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceReplicaSetCondition + */ + reason?: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceReplicaSetCondition + */ + status: string; + /** + * + * @type {string} + * @memberof V1VirtualMachineInstanceReplicaSetCondition + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetList.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetList.ts new file mode 100644 index 00000000000..9edd2bd7271 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ListMeta } from './V1ListMeta'; +import { V1VirtualMachineInstanceReplicaSet } from './V1VirtualMachineInstanceReplicaSet'; + +/** + * VMIList is a list of VMIs + * @export + * @interface V1VirtualMachineInstanceReplicaSetList + */ +export interface V1VirtualMachineInstanceReplicaSetList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1VirtualMachineInstanceReplicaSetList + */ + apiVersion?: string; + /** + * + * @type {Array} + * @memberof V1VirtualMachineInstanceReplicaSetList + */ + items: V1VirtualMachineInstanceReplicaSet[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1VirtualMachineInstanceReplicaSetList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1VirtualMachineInstanceReplicaSetList + */ + metadata?: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetSpec.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetSpec.ts new file mode 100644 index 00000000000..9f15159f698 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetSpec.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1LabelSelector } from './V1LabelSelector'; +import { V1VirtualMachineInstanceTemplateSpec } from './V1VirtualMachineInstanceTemplateSpec'; + +/** + * + * @export + * @interface V1VirtualMachineInstanceReplicaSetSpec + */ +export interface V1VirtualMachineInstanceReplicaSetSpec { + /** + * Indicates that the replica set is paused. +optional + * @type {boolean} + * @memberof V1VirtualMachineInstanceReplicaSetSpec + */ + paused?: boolean; + /** + * Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1. +optional + * @type {number} + * @memberof V1VirtualMachineInstanceReplicaSetSpec + */ + replicas?: number; + /** + * + * @type {V1LabelSelector} + * @memberof V1VirtualMachineInstanceReplicaSetSpec + */ + selector: V1LabelSelector; + /** + * + * @type {V1VirtualMachineInstanceTemplateSpec} + * @memberof V1VirtualMachineInstanceReplicaSetSpec + */ + template: V1VirtualMachineInstanceTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetStatus.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetStatus.ts new file mode 100644 index 00000000000..ee48e11f31b --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceReplicaSetStatus.ts @@ -0,0 +1,46 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1VirtualMachineInstanceReplicaSetCondition } from './V1VirtualMachineInstanceReplicaSetCondition'; + +/** + * + * @export + * @interface V1VirtualMachineInstanceReplicaSetStatus + */ +export interface V1VirtualMachineInstanceReplicaSetStatus { + /** + * + * @type {Array} + * @memberof V1VirtualMachineInstanceReplicaSetStatus + */ + conditions?: V1VirtualMachineInstanceReplicaSetCondition[]; + /** + * Canonical form of the label selector for HPA which consumes it through the scale subresource. + * @type {string} + * @memberof V1VirtualMachineInstanceReplicaSetStatus + */ + labelSelector?: string; + /** + * The number of ready replicas for this replica set. +optional + * @type {number} + * @memberof V1VirtualMachineInstanceReplicaSetStatus + */ + readyReplicas?: number; + /** + * Total number of non-terminated pods targeted by this deployment (their labels match the selector). +optional + * @type {number} + * @memberof V1VirtualMachineInstanceReplicaSetStatus + */ + replicas?: number; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceSpec.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceSpec.ts new file mode 100644 index 00000000000..e90393afc94 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceSpec.ts @@ -0,0 +1,112 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1Affinity } from './V1Affinity'; +import { V1DomainSpec } from './V1DomainSpec'; +import { V1Network } from './V1Network'; +import { V1PodDNSConfig } from './V1PodDNSConfig'; +import { V1Probe } from './V1Probe'; +import { V1Toleration } from './V1Toleration'; +import { V1Volume } from './V1Volume'; + +/** + * VirtualMachineInstanceSpec is a description of a VirtualMachineInstance. + * @export + * @interface V1VirtualMachineInstanceSpec + */ +export interface V1VirtualMachineInstanceSpec { + /** + * + * @type {V1Affinity} + * @memberof V1VirtualMachineInstanceSpec + */ + affinity?: V1Affinity; + /** + * + * @type {V1PodDNSConfig} + * @memberof V1VirtualMachineInstanceSpec + */ + dnsConfig?: V1PodDNSConfig; + /** + * Set DNS policy for the pod. Defaults to \"ClusterFirst\". Valid values are \'ClusterFirstWithHostNet\', \'ClusterFirst\', \'Default\' or \'None\'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to \'ClusterFirstWithHostNet\'. +optional + * @type {string} + * @memberof V1VirtualMachineInstanceSpec + */ + dnsPolicy?: string; + /** + * + * @type {V1DomainSpec} + * @memberof V1VirtualMachineInstanceSpec + */ + domain: V1DomainSpec; + /** + * + * @type {object} + * @memberof V1VirtualMachineInstanceSpec + */ + evictionStrategy?: object; + /** + * Specifies the hostname of the vmi If not specified, the hostname will be set to the name of the vmi, if dhcp or cloud-init is configured properly. +optional + * @type {string} + * @memberof V1VirtualMachineInstanceSpec + */ + hostname?: string; + /** + * + * @type {V1Probe} + * @memberof V1VirtualMachineInstanceSpec + */ + livenessProbe?: V1Probe; + /** + * List of networks that can be attached to a vm\'s virtual interface. + * @type {Array} + * @memberof V1VirtualMachineInstanceSpec + */ + networks?: V1Network[]; + /** + * NodeSelector is a selector which must be true for the vmi to fit on a node. Selector which must match a node\'s labels for the vmi to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/ +optional + * @type {object} + * @memberof V1VirtualMachineInstanceSpec + */ + nodeSelector?: object; + /** + * + * @type {V1Probe} + * @memberof V1VirtualMachineInstanceSpec + */ + readinessProbe?: V1Probe; + /** + * If specified, the fully qualified vmi hostname will be \"...svc.\". If not specified, the vmi will not have a domainname at all. The DNS entry will resolve to the vmi, no matter if the vmi itself can pick up a hostname. +optional + * @type {string} + * @memberof V1VirtualMachineInstanceSpec + */ + subdomain?: string; + /** + * Grace period observed after signalling a VirtualMachineInstance to stop after which the VirtualMachineInstance is force terminated. + * @type {number} + * @memberof V1VirtualMachineInstanceSpec + */ + terminationGracePeriodSeconds?: number; + /** + * If toleration is specified, obey all the toleration rules. + * @type {Array} + * @memberof V1VirtualMachineInstanceSpec + */ + tolerations?: V1Toleration[]; + /** + * List of volumes that can be mounted by disks belonging to the vmi. + * @type {Array} + * @memberof V1VirtualMachineInstanceSpec + */ + volumes?: V1Volume[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceStatus.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceStatus.ts new file mode 100644 index 00000000000..766384d420d --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceStatus.ts @@ -0,0 +1,72 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1VirtualMachineInstanceCondition } from './V1VirtualMachineInstanceCondition'; +import { V1VirtualMachineInstanceMigrationState } from './V1VirtualMachineInstanceMigrationState'; +import { V1VirtualMachineInstanceNetworkInterface } from './V1VirtualMachineInstanceNetworkInterface'; + +/** + * VirtualMachineInstanceStatus represents information about the status of a VirtualMachineInstance. Status may trail the actual state of a system. + * @export + * @interface V1VirtualMachineInstanceStatus + */ +export interface V1VirtualMachineInstanceStatus { + /** + * Conditions are specific points in VirtualMachineInstance\'s pod runtime. + * @type {Array} + * @memberof V1VirtualMachineInstanceStatus + */ + conditions?: V1VirtualMachineInstanceCondition[]; + /** + * Interfaces represent the details of available network interfaces. + * @type {Array} + * @memberof V1VirtualMachineInstanceStatus + */ + interfaces?: V1VirtualMachineInstanceNetworkInterface[]; + /** + * Represents the method using which the vmi can be migrated: live migration or block migration + * @type {string} + * @memberof V1VirtualMachineInstanceStatus + */ + migrationMethod?: string; + /** + * + * @type {V1VirtualMachineInstanceMigrationState} + * @memberof V1VirtualMachineInstanceStatus + */ + migrationState?: V1VirtualMachineInstanceMigrationState; + /** + * NodeName is the name where the VirtualMachineInstance is currently running. + * @type {string} + * @memberof V1VirtualMachineInstanceStatus + */ + nodeName?: string; + /** + * Phase is the status of the VirtualMachineInstance in kubernetes world. It is not the VirtualMachineInstance status, but partially correlates to it. + * @type {string} + * @memberof V1VirtualMachineInstanceStatus + */ + phase?: string; + /** + * + * @type {object} + * @memberof V1VirtualMachineInstanceStatus + */ + qosClass?: object; + /** + * A brief CamelCase message indicating details about why the VMI is in this state. e.g. \'NodeUnresponsive\' +optional + * @type {string} + * @memberof V1VirtualMachineInstanceStatus + */ + reason?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceTemplateSpec.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceTemplateSpec.ts new file mode 100644 index 00000000000..fdf75bfa839 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineInstanceTemplateSpec.ts @@ -0,0 +1,35 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { V1VirtualMachineInstanceSpec } from './V1VirtualMachineInstanceSpec'; + +/** + * + * @export + * @interface V1VirtualMachineInstanceTemplateSpec + */ +export interface V1VirtualMachineInstanceTemplateSpec { + /** + * + * @type {V1ObjectMeta} + * @memberof V1VirtualMachineInstanceTemplateSpec + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1VirtualMachineInstanceSpec} + * @memberof V1VirtualMachineInstanceTemplateSpec + */ + spec?: V1VirtualMachineInstanceSpec; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineList.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineList.ts new file mode 100644 index 00000000000..dc7de8d3ac2 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineList.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ListMeta } from './V1ListMeta'; +import { V1VirtualMachine } from './V1VirtualMachine'; + +/** + * VirtualMachineList is a list of virtualmachines + * @export + * @interface V1VirtualMachineList + */ +export interface V1VirtualMachineList { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1VirtualMachineList + */ + apiVersion?: string; + /** + * Items is a list of VirtualMachines + * @type {Array} + * @memberof V1VirtualMachineList + */ + items: V1VirtualMachine[]; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1VirtualMachineList + */ + kind?: string; + /** + * + * @type {V1ListMeta} + * @memberof V1VirtualMachineList + */ + metadata: V1ListMeta; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineSpec.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineSpec.ts new file mode 100644 index 00000000000..a7fd62a542d --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineSpec.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1VirtualMachineInstanceTemplateSpec } from './V1VirtualMachineInstanceTemplateSpec'; +import { V1alpha1DataVolume } from './V1alpha1DataVolume'; + +/** + * VirtualMachineSpec describes how the proper VirtualMachine should look like + * @export + * @interface V1VirtualMachineSpec + */ +export interface V1VirtualMachineSpec { + /** + * dataVolumeTemplates is a list of dataVolumes that the VirtualMachineInstance template can reference. DataVolumes in this list are dynamically created for the VirtualMachine and are tied to the VirtualMachine\'s life-cycle. + * @type {Array} + * @memberof V1VirtualMachineSpec + */ + dataVolumeTemplates?: V1alpha1DataVolume[]; + /** + * + * @type {object} + * @memberof V1VirtualMachineSpec + */ + runStrategy?: object; + /** + * Running controls whether the associatied VirtualMachineInstance is created or not Mutually exclusive with RunStrategy + * @type {boolean} + * @memberof V1VirtualMachineSpec + */ + running?: boolean; + /** + * + * @type {V1VirtualMachineInstanceTemplateSpec} + * @memberof V1VirtualMachineSpec + */ + template: V1VirtualMachineInstanceTemplateSpec; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineStateChangeRequest.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineStateChangeRequest.ts new file mode 100644 index 00000000000..d7d499ab6f0 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineStateChangeRequest.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1VirtualMachineStateChangeRequest + */ +export interface V1VirtualMachineStateChangeRequest { + /** + * Indicates the type of action that is requested. e.g. Start or Stop + * @type {string} + * @memberof V1VirtualMachineStateChangeRequest + */ + action: string; + /** + * + * @type {object} + * @memberof V1VirtualMachineStateChangeRequest + */ + uid?: object; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineStatus.ts b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineStatus.ts new file mode 100644 index 00000000000..1f1b2452eda --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1VirtualMachineStatus.ts @@ -0,0 +1,47 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1VirtualMachineCondition } from './V1VirtualMachineCondition'; +import { V1VirtualMachineStateChangeRequest } from './V1VirtualMachineStateChangeRequest'; + +/** + * VirtualMachineStatus represents the status returned by the controller to describe how the VirtualMachine is doing + * @export + * @interface V1VirtualMachineStatus + */ +export interface V1VirtualMachineStatus { + /** + * Hold the state information of the VirtualMachine and its VirtualMachineInstance + * @type {Array} + * @memberof V1VirtualMachineStatus + */ + conditions?: V1VirtualMachineCondition[]; + /** + * Created indicates if the virtual machine is created in the cluster + * @type {boolean} + * @memberof V1VirtualMachineStatus + */ + created?: boolean; + /** + * Ready indicates if the virtual machine is running and ready + * @type {boolean} + * @memberof V1VirtualMachineStatus + */ + ready?: boolean; + /** + * StateChangeRequests indicates a list of actions that should be taken on a VMI e.g. stop a specific VMI then start a new one. + * @type {Array} + * @memberof V1VirtualMachineStatus + */ + stateChangeRequests?: V1VirtualMachineStateChangeRequest[]; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Volume.ts b/frontend/packages/kube-types/src/kubevirt/V1Volume.ts new file mode 100644 index 00000000000..dc54d65d1f4 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Volume.ts @@ -0,0 +1,104 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1CloudInitConfigDriveSource } from './V1CloudInitConfigDriveSource'; +import { V1CloudInitNoCloudSource } from './V1CloudInitNoCloudSource'; +import { V1ConfigMapVolumeSource } from './V1ConfigMapVolumeSource'; +import { V1ContainerDiskSource } from './V1ContainerDiskSource'; +import { V1DataVolumeSource } from './V1DataVolumeSource'; +import { V1EmptyDiskSource } from './V1EmptyDiskSource'; +import { V1EphemeralVolumeSource } from './V1EphemeralVolumeSource'; +import { V1HostDisk } from './V1HostDisk'; +import { V1PersistentVolumeClaimVolumeSource } from './V1PersistentVolumeClaimVolumeSource'; +import { V1SecretVolumeSource } from './V1SecretVolumeSource'; +import { V1ServiceAccountVolumeSource } from './V1ServiceAccountVolumeSource'; + +/** + * Volume represents a named volume in a vmi. + * @export + * @interface V1Volume + */ +export interface V1Volume { + /** + * + * @type {V1CloudInitConfigDriveSource} + * @memberof V1Volume + */ + cloudInitConfigDrive?: V1CloudInitConfigDriveSource; + /** + * + * @type {V1CloudInitNoCloudSource} + * @memberof V1Volume + */ + cloudInitNoCloud?: V1CloudInitNoCloudSource; + /** + * + * @type {V1ConfigMapVolumeSource} + * @memberof V1Volume + */ + configMap?: V1ConfigMapVolumeSource; + /** + * + * @type {V1ContainerDiskSource} + * @memberof V1Volume + */ + containerDisk?: V1ContainerDiskSource; + /** + * + * @type {V1DataVolumeSource} + * @memberof V1Volume + */ + dataVolume?: V1DataVolumeSource; + /** + * + * @type {V1EmptyDiskSource} + * @memberof V1Volume + */ + emptyDisk?: V1EmptyDiskSource; + /** + * + * @type {V1EphemeralVolumeSource} + * @memberof V1Volume + */ + ephemeral?: V1EphemeralVolumeSource; + /** + * + * @type {V1HostDisk} + * @memberof V1Volume + */ + hostDisk?: V1HostDisk; + /** + * Volume\'s name. Must be a DNS_LABEL and unique within the vmi. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + * @type {string} + * @memberof V1Volume + */ + name: string; + /** + * + * @type {V1PersistentVolumeClaimVolumeSource} + * @memberof V1Volume + */ + persistentVolumeClaim?: V1PersistentVolumeClaimVolumeSource; + /** + * + * @type {V1SecretVolumeSource} + * @memberof V1Volume + */ + secret?: V1SecretVolumeSource; + /** + * + * @type {V1ServiceAccountVolumeSource} + * @memberof V1Volume + */ + serviceAccount?: V1ServiceAccountVolumeSource; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1WatchEvent.ts b/frontend/packages/kube-types/src/kubevirt/V1WatchEvent.ts new file mode 100644 index 00000000000..306d0b1d8e7 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1WatchEvent.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * + * @export + * @interface V1WatchEvent + */ +export interface V1WatchEvent { + /** + * + * @type {string} + * @memberof V1WatchEvent + */ + object: string; + /** + * + * @type {string} + * @memberof V1WatchEvent + */ + type: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1Watchdog.ts b/frontend/packages/kube-types/src/kubevirt/V1Watchdog.ts new file mode 100644 index 00000000000..2c3c50a301f --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1Watchdog.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1I6300ESBWatchdog } from './V1I6300ESBWatchdog'; + +/** + * Named watchdog device. + * @export + * @interface V1Watchdog + */ +export interface V1Watchdog { + /** + * + * @type {V1I6300ESBWatchdog} + * @memberof V1Watchdog + */ + i6300esb?: V1I6300ESBWatchdog; + /** + * Name of the watchdog. + * @type {string} + * @memberof V1Watchdog + */ + name: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1WeightedPodAffinityTerm.ts b/frontend/packages/kube-types/src/kubevirt/V1WeightedPodAffinityTerm.ts new file mode 100644 index 00000000000..18ea61a2ff1 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1WeightedPodAffinityTerm.ts @@ -0,0 +1,34 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PodAffinityTerm } from './V1PodAffinityTerm'; + +/** + * The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s) + * @export + * @interface V1WeightedPodAffinityTerm + */ +export interface V1WeightedPodAffinityTerm { + /** + * + * @type {V1PodAffinityTerm} + * @memberof V1WeightedPodAffinityTerm + */ + podAffinityTerm: V1PodAffinityTerm; + /** + * weight associated with matching the corresponding podAffinityTerm, in the range 1-100. + * @type {number} + * @memberof V1WeightedPodAffinityTerm + */ + weight: number; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolume.ts b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolume.ts new file mode 100644 index 00000000000..27fe82345bf --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolume.ts @@ -0,0 +1,54 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1ObjectMeta } from './V1ObjectMeta'; +import { V1alpha1DataVolumeSpec } from './V1alpha1DataVolumeSpec'; +import { V1alpha1DataVolumeStatus } from './V1alpha1DataVolumeStatus'; + +/** + * DataVolume provides a representation of our data volume +genclient +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + * @export + * @interface V1alpha1DataVolume + */ +export interface V1alpha1DataVolume { + /** + * APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources + * @type {string} + * @memberof V1alpha1DataVolume + */ + apiVersion?: string; + /** + * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds + * @type {string} + * @memberof V1alpha1DataVolume + */ + kind?: string; + /** + * + * @type {V1ObjectMeta} + * @memberof V1alpha1DataVolume + */ + metadata?: V1ObjectMeta; + /** + * + * @type {V1alpha1DataVolumeSpec} + * @memberof V1alpha1DataVolume + */ + spec: V1alpha1DataVolumeSpec; + /** + * + * @type {V1alpha1DataVolumeStatus} + * @memberof V1alpha1DataVolume + */ + status?: V1alpha1DataVolumeStatus; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSource.ts b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSource.ts new file mode 100644 index 00000000000..cec7495735e --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSource.ts @@ -0,0 +1,61 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1alpha1DataVolumeSourceHTTP } from './V1alpha1DataVolumeSourceHTTP'; +import { V1alpha1DataVolumeSourcePVC } from './V1alpha1DataVolumeSourcePVC'; +import { V1alpha1DataVolumeSourceRegistry } from './V1alpha1DataVolumeSourceRegistry'; +import { V1alpha1DataVolumeSourceS3 } from './V1alpha1DataVolumeSourceS3'; + +/** + * DataVolumeSource represents the source for our Data Volume, this can be HTTP, S3, Registry or an existing PVC + * @export + * @interface V1alpha1DataVolumeSource + */ +export interface V1alpha1DataVolumeSource { + /** + * DataVolumeBlankImage provides the parameters to create a new raw blank image for the PVC + * @type {object} + * @memberof V1alpha1DataVolumeSource + */ + blank?: object; + /** + * + * @type {V1alpha1DataVolumeSourceHTTP} + * @memberof V1alpha1DataVolumeSource + */ + http?: V1alpha1DataVolumeSourceHTTP; + /** + * + * @type {V1alpha1DataVolumeSourcePVC} + * @memberof V1alpha1DataVolumeSource + */ + pvc?: V1alpha1DataVolumeSourcePVC; + /** + * + * @type {V1alpha1DataVolumeSourceRegistry} + * @memberof V1alpha1DataVolumeSource + */ + registry?: V1alpha1DataVolumeSourceRegistry; + /** + * + * @type {V1alpha1DataVolumeSourceS3} + * @memberof V1alpha1DataVolumeSource + */ + s3?: V1alpha1DataVolumeSourceS3; + /** + * DataVolumeSourceUpload provides the parameters to create a Data Volume by uploading the source + * @type {object} + * @memberof V1alpha1DataVolumeSource + */ + upload?: object; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceHTTP.ts b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceHTTP.ts new file mode 100644 index 00000000000..66b962671de --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceHTTP.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DataVolumeSourceHTTP provides the parameters to create a Data Volume from an HTTP source + * @export + * @interface V1alpha1DataVolumeSourceHTTP + */ +export interface V1alpha1DataVolumeSourceHTTP { + /** + * CertConfigMap provides a reference to the Registry certs + * @type {string} + * @memberof V1alpha1DataVolumeSourceHTTP + */ + certConfigMap?: string; + /** + * SecretRef provides the secret reference needed to access the HTTP source + * @type {string} + * @memberof V1alpha1DataVolumeSourceHTTP + */ + secretRef?: string; + /** + * URL is the URL of the http source + * @type {string} + * @memberof V1alpha1DataVolumeSourceHTTP + */ + url?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourcePVC.ts b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourcePVC.ts new file mode 100644 index 00000000000..0de02d097c7 --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourcePVC.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DataVolumeSourcePVC provides the parameters to create a Data Volume from an existing PVC + * @export + * @interface V1alpha1DataVolumeSourcePVC + */ +export interface V1alpha1DataVolumeSourcePVC { + /** + * + * @type {string} + * @memberof V1alpha1DataVolumeSourcePVC + */ + name?: string; + /** + * + * @type {string} + * @memberof V1alpha1DataVolumeSourcePVC + */ + namespace?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceRegistry.ts b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceRegistry.ts new file mode 100644 index 00000000000..144ffb0f9aa --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceRegistry.ts @@ -0,0 +1,38 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DataVolumeSourceRegistry provides the parameters to create a Data Volume from an registry source + * @export + * @interface V1alpha1DataVolumeSourceRegistry + */ +export interface V1alpha1DataVolumeSourceRegistry { + /** + * CertConfigMap provides a reference to the Registry certs + * @type {string} + * @memberof V1alpha1DataVolumeSourceRegistry + */ + certConfigMap?: string; + /** + * SecretRef provides the secret reference needed to access the Registry source + * @type {string} + * @memberof V1alpha1DataVolumeSourceRegistry + */ + secretRef?: string; + /** + * URL is the url of the Registry source + * @type {string} + * @memberof V1alpha1DataVolumeSourceRegistry + */ + url?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceS3.ts b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceS3.ts new file mode 100644 index 00000000000..b9597159bda --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSourceS3.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DataVolumeSourceS3 provides the parameters to create a Data Volume from an S3 source + * @export + * @interface V1alpha1DataVolumeSourceS3 + */ +export interface V1alpha1DataVolumeSourceS3 { + /** + * SecretRef provides the secret reference needed to access the S3 source + * @type {string} + * @memberof V1alpha1DataVolumeSourceS3 + */ + secretRef?: string; + /** + * URL is the url of the S3 source + * @type {string} + * @memberof V1alpha1DataVolumeSourceS3 + */ + url?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSpec.ts b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSpec.ts new file mode 100644 index 00000000000..ec125acb7ba --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeSpec.ts @@ -0,0 +1,41 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +import { V1PersistentVolumeClaimSpec } from './V1PersistentVolumeClaimSpec'; +import { V1alpha1DataVolumeSource } from './V1alpha1DataVolumeSource'; + +/** + * DataVolumeSpec defines our specification for a DataVolume type + * @export + * @interface V1alpha1DataVolumeSpec + */ +export interface V1alpha1DataVolumeSpec { + /** + * DataVolumeContentType options: \"kubevirt\", \"archive\" + * @type {string} + * @memberof V1alpha1DataVolumeSpec + */ + contentType?: string; + /** + * + * @type {V1PersistentVolumeClaimSpec} + * @memberof V1alpha1DataVolumeSpec + */ + pvc: V1PersistentVolumeClaimSpec; + /** + * + * @type {V1alpha1DataVolumeSource} + * @memberof V1alpha1DataVolumeSpec + */ + source: V1alpha1DataVolumeSource; +} diff --git a/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeStatus.ts b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeStatus.ts new file mode 100644 index 00000000000..4305660e26a --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/V1alpha1DataVolumeStatus.ts @@ -0,0 +1,32 @@ +// tslint:disable +/** + * KubeVirt API + * This is KubeVirt API an add-on for Kubernetes. + * + * The version of the OpenAPI document: 1.0.0 + * Contact: kubevirt-dev@googlegroups.com + * + * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). + * https://openapi-generator.tech + * Do not edit the class manually. + */ + +/** + * DataVolumeStatus provides the parameters to store the phase of the Data Volume + * @export + * @interface V1alpha1DataVolumeStatus + */ +export interface V1alpha1DataVolumeStatus { + /** + * Phase is the current phase of the data volume + * @type {string} + * @memberof V1alpha1DataVolumeStatus + */ + phase?: string; + /** + * + * @type {string} + * @memberof V1alpha1DataVolumeStatus + */ + progress?: string; +} diff --git a/frontend/packages/kube-types/src/kubevirt/index.ts b/frontend/packages/kube-types/src/kubevirt/index.ts new file mode 100644 index 00000000000..97b469d8c4a --- /dev/null +++ b/frontend/packages/kube-types/src/kubevirt/index.ts @@ -0,0 +1,127 @@ +export * from './V1APIGroup'; +export * from './V1APIGroupList'; +export * from './V1APIResource'; +export * from './V1APIResourceList'; +export * from './V1Affinity'; +export * from './V1Bootloader'; +export * from './V1CDRomTarget'; +export * from './V1CPU'; +export * from './V1CPUFeature'; +export * from './V1Clock'; +export * from './V1ClockOffsetUTC'; +export * from './V1CloudInitConfigDriveSource'; +export * from './V1CloudInitNoCloudSource'; +export * from './V1ConfigMapVolumeSource'; +export * from './V1ContainerDiskSource'; +export * from './V1DHCPOptions'; +export * from './V1DHCPPrivateOptions'; +export * from './V1DataVolumeSource'; +export * from './V1DeleteOptions'; +export * from './V1Devices'; +export * from './V1Disk'; +export * from './V1DiskTarget'; +export * from './V1DomainSpec'; +export * from './V1EmptyDiskSource'; +export * from './V1EphemeralVolumeSource'; +export * from './V1FeatureAPIC'; +export * from './V1FeatureHyperv'; +export * from './V1FeatureSpinlocks'; +export * from './V1FeatureState'; +export * from './V1FeatureVendorID'; +export * from './V1Features'; +export * from './V1Firmware'; +export * from './V1FloppyTarget'; +export * from './V1GenieNetwork'; +export * from './V1GroupVersionForDiscovery'; +export * from './V1HPETTimer'; +export * from './V1HTTPGetAction'; +export * from './V1HTTPHeader'; +export * from './V1HostDisk'; +export * from './V1Hugepages'; +export * from './V1HypervTimer'; +export * from './V1I6300ESBWatchdog'; +export * from './V1Initializer'; +export * from './V1Initializers'; +export * from './V1Input'; +export * from './V1Interface'; +export * from './V1KVMTimer'; +export * from './V1LabelSelector'; +export * from './V1LabelSelectorRequirement'; +export * from './V1ListMeta'; +export * from './V1LocalObjectReference'; +export * from './V1LunTarget'; +export * from './V1Machine'; +export * from './V1Memory'; +export * from './V1MultusNetwork'; +export * from './V1Network'; +export * from './V1NodeAffinity'; +export * from './V1NodeSelector'; +export * from './V1NodeSelectorRequirement'; +export * from './V1NodeSelectorTerm'; +export * from './V1ObjectMeta'; +export * from './V1OwnerReference'; +export * from './V1PITTimer'; +export * from './V1PersistentVolumeClaimSpec'; +export * from './V1PersistentVolumeClaimVolumeSource'; +export * from './V1PodAffinity'; +export * from './V1PodAffinityTerm'; +export * from './V1PodAntiAffinity'; +export * from './V1PodDNSConfig'; +export * from './V1PodDNSConfigOption'; +export * from './V1PodNetwork'; +export * from './V1Port'; +export * from './V1Preconditions'; +export * from './V1PreferredSchedulingTerm'; +export * from './V1Probe'; +export * from './V1RTCTimer'; +export * from './V1ResourceRequirements'; +export * from './V1RootPaths'; +export * from './V1SecretVolumeSource'; +export * from './V1ServerAddressByClientCIDR'; +export * from './V1ServiceAccountVolumeSource'; +export * from './V1Status'; +export * from './V1StatusCause'; +export * from './V1StatusDetails'; +export * from './V1TCPSocketAction'; +export * from './V1Timer'; +export * from './V1Toleration'; +export * from './V1TypedLocalObjectReference'; +export * from './V1VirtualMachine'; +export * from './V1VirtualMachineCondition'; +export * from './V1VirtualMachineInstance'; +export * from './V1VirtualMachineInstanceCondition'; +export * from './V1VirtualMachineInstanceList'; +export * from './V1VirtualMachineInstanceMigration'; +export * from './V1VirtualMachineInstanceMigrationCondition'; +export * from './V1VirtualMachineInstanceMigrationList'; +export * from './V1VirtualMachineInstanceMigrationSpec'; +export * from './V1VirtualMachineInstanceMigrationState'; +export * from './V1VirtualMachineInstanceMigrationStatus'; +export * from './V1VirtualMachineInstanceNetworkInterface'; +export * from './V1VirtualMachineInstancePreset'; +export * from './V1VirtualMachineInstancePresetList'; +export * from './V1VirtualMachineInstancePresetSpec'; +export * from './V1VirtualMachineInstanceReplicaSet'; +export * from './V1VirtualMachineInstanceReplicaSetCondition'; +export * from './V1VirtualMachineInstanceReplicaSetList'; +export * from './V1VirtualMachineInstanceReplicaSetSpec'; +export * from './V1VirtualMachineInstanceReplicaSetStatus'; +export * from './V1VirtualMachineInstanceSpec'; +export * from './V1VirtualMachineInstanceStatus'; +export * from './V1VirtualMachineInstanceTemplateSpec'; +export * from './V1VirtualMachineList'; +export * from './V1VirtualMachineSpec'; +export * from './V1VirtualMachineStateChangeRequest'; +export * from './V1VirtualMachineStatus'; +export * from './V1Volume'; +export * from './V1WatchEvent'; +export * from './V1Watchdog'; +export * from './V1WeightedPodAffinityTerm'; +export * from './V1alpha1DataVolume'; +export * from './V1alpha1DataVolumeSource'; +export * from './V1alpha1DataVolumeSourceHTTP'; +export * from './V1alpha1DataVolumeSourcePVC'; +export * from './V1alpha1DataVolumeSourceRegistry'; +export * from './V1alpha1DataVolumeSourceS3'; +export * from './V1alpha1DataVolumeSpec'; +export * from './V1alpha1DataVolumeStatus';