require('./sourcemap-register.js');module.exports =
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 94822:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const core = __importStar(__webpack_require__(42186));
const model_1 = __webpack_require__(41359);
const platform_setup_1 = __importDefault(__webpack_require__(64423));
function run() {
return __awaiter(this, void 0, void 0, function* () {
try {
model_1.Action.checkCompatibility();
model_1.Cache.verify();
const { dockerfile, workspace, actionFolder } = model_1.Action;
const buildParameters = yield model_1.BuildParameters.create();
const baseImage = new model_1.ImageTag(buildParameters);
let builtImage;
switch (buildParameters.remoteBuildCluster) {
case 'k8s':
core.info('Building with Kubernetes');
yield model_1.Kubernetes.runBuildJob(buildParameters, baseImage);
break;
case 'aws':
core.info('Building with AWS');
yield model_1.RemoteBuilder.build(buildParameters, baseImage);
break;
// default and local case
default:
core.info('Building locally');
platform_setup_1.default.setup(buildParameters);
builtImage = yield model_1.Docker.build({ path: actionFolder, dockerfile, baseImage });
yield model_1.Docker.run(builtImage, Object.assign({ workspace }, buildParameters));
break;
}
// Set output
yield model_1.Output.setBuildVersion(buildParameters.buildVersion);
}
catch (error) {
core.setFailed(error.message);
}
});
}
run();
/***/ }),
/***/ 89088:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const path_1 = __importDefault(__webpack_require__(85622));
class Action {
static get supportedPlatforms() {
return ['linux', 'win32'];
}
static get isRunningLocally() {
return process.env.RUNNER_WORKSPACE === undefined;
}
static get isRunningFromSource() {
return path_1.default.basename(__dirname) === 'model';
}
static get canonicalName() {
return 'unity-builder';
}
static get rootFolder() {
if (Action.isRunningFromSource) {
return path_1.default.dirname(path_1.default.dirname(path_1.default.dirname(__filename)));
}
return path_1.default.dirname(path_1.default.dirname(__filename));
}
static get actionFolder() {
return `${Action.rootFolder}/dist`;
}
static get dockerfile() {
const currentPlatform = process.platform;
switch (currentPlatform) {
case 'linux':
return `${Action.actionFolder}/platforms/ubuntu/Dockerfile`;
case 'win32':
return `${Action.actionFolder}/platforms/windows/Dockerfile`;
default:
throw new Error(`No Dockerfile for currently unsupported platform: ${currentPlatform}`);
}
}
static get workspace() {
return process.env.GITHUB_WORKSPACE;
}
static checkCompatibility() {
const currentPlatform = process.platform;
if (!Action.supportedPlatforms.includes(currentPlatform)) {
throw new Error(`Currently ${currentPlatform}-platform is not supported`);
}
}
}
exports.default = Action;
/***/ }),
/***/ 43059:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const core = __importStar(__webpack_require__(42186));
const semver = __importStar(__webpack_require__(11383));
class AndroidVersioning {
static determineVersionCode(version, inputVersionCode) {
if (!inputVersionCode) {
return AndroidVersioning.versionToVersionCode(version);
}
return inputVersionCode;
}
static versionToVersionCode(version) {
if (version === 'none') {
core.info(`Versioning strategy is set to ${version}, so android version code should not be applied.`);
return 0;
}
const parsedVersion = semver.parse(version);
if (!parsedVersion) {
core.warning(`Could not parse "${version}" to semver, defaulting android version code to 1`);
return 1;
}
// The greatest value Google Plays allows is 2100000000.
// Allow for 3 patch digits, 3 minor digits and 3 major digits.
const versionCode = parsedVersion.major * 1000000 + parsedVersion.minor * 1000 + parsedVersion.patch;
if (versionCode >= 2050000000) {
throw new Error(`Generated versionCode ${versionCode} is dangerously close to the maximum allowed number 2100000000. Consider a different versioning scheme to be able to continue updating your application.`);
}
core.info(`Using android versionCode ${versionCode}`);
return versionCode;
}
static determineSdkManagerParameters(targetSdkVersion) {
const parsedVersion = Number.parseInt(targetSdkVersion.slice(-2), 10);
return Number.isNaN(parsedVersion) ? '' : `platforms;android-${parsedVersion}`;
}
}
exports.default = AndroidVersioning;
/***/ }),
/***/ 80787:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const core = __importStar(__webpack_require__(42186));
const android_versioning_1 = __importDefault(__webpack_require__(43059));
const input_1 = __importDefault(__webpack_require__(91933));
const platform_1 = __importDefault(__webpack_require__(9707));
const unity_versioning_1 = __importDefault(__webpack_require__(17146));
const versioning_1 = __importDefault(__webpack_require__(88729));
class BuildParameters {
static create() {
return __awaiter(this, void 0, void 0, function* () {
const buildFile = this.parseBuildFile(input_1.default.buildName, input_1.default.targetPlatform, input_1.default.androidAppBundle);
const unityVersion = unity_versioning_1.default.determineUnityVersion(input_1.default.projectPath, input_1.default.unityVersion);
const buildVersion = yield versioning_1.default.determineVersion(input_1.default.versioningStrategy, input_1.default.specifiedVersion);
const androidVersionCode = android_versioning_1.default.determineVersionCode(buildVersion, input_1.default.androidVersionCode);
const androidSdkManagerParameters = android_versioning_1.default.determineSdkManagerParameters(input_1.default.androidTargetSdkVersion);
let unitySerial = '';
if (!process.env.UNITY_SERIAL) {
//No serial was present so it is a personal license that we need to convert
if (!process.env.UNITY_LICENSE) {
throw new Error(`Missing Unity License File and no Serial was found. If this
is a personal license, make sure to follow the activation
steps and set the UNITY_LICENSE GitHub secret or enter a Unity
serial number inside the UNITY_SERIAL GitHub secret.`);
}
unitySerial = this.getSerialFromLicenseFile(process.env.UNITY_LICENSE);
}
else {
unitySerial = process.env.UNITY_SERIAL;
}
core.setSecret(unitySerial);
return {
version: unityVersion,
customImage: input_1.default.customImage,
unitySerial,
runnerTempPath: process.env.RUNNER_TEMP,
platform: input_1.default.targetPlatform,
projectPath: input_1.default.projectPath,
buildName: input_1.default.buildName,
buildPath: `${input_1.default.buildsPath}/${input_1.default.targetPlatform}`,
buildFile,
buildMethod: input_1.default.buildMethod,
buildVersion,
androidVersionCode,
androidKeystoreName: input_1.default.androidKeystoreName,
androidKeystoreBase64: input_1.default.androidKeystoreBase64,
androidKeystorePass: input_1.default.androidKeystorePass,
androidKeyaliasName: input_1.default.androidKeyaliasName,
androidKeyaliasPass: input_1.default.androidKeyaliasPass,
androidTargetSdkVersion: input_1.default.androidTargetSdkVersion,
androidSdkManagerParameters,
customParameters: input_1.default.customParameters,
sshAgent: input_1.default.sshAgent,
gitPrivateToken: input_1.default.gitPrivateToken,
chownFilesTo: input_1.default.chownFilesTo,
remoteBuildCluster: input_1.default.remoteBuildCluster,
awsStackName: input_1.default.awsStackName,
kubeConfig: input_1.default.kubeConfig,
githubToken: input_1.default.githubToken,
remoteBuildMemory: input_1.default.remoteBuildMemory,
remoteBuildCpu: input_1.default.remoteBuildCpu,
kubeVolumeSize: input_1.default.kubeVolumeSize,
kubeVolume: input_1.default.kubeVolume,
};
});
}
static parseBuildFile(filename, platform, androidAppBundle) {
if (platform_1.default.isWindows(platform)) {
return `${filename}.exe`;
}
if (platform_1.default.isAndroid(platform)) {
return androidAppBundle ? `${filename}.aab` : `${filename}.apk`;
}
return filename;
}
static getSerialFromLicenseFile(license) {
const startKey = ``;
const startIndex = license.indexOf(startKey) + startKey.length;
if (startIndex < 0) {
throw new Error(`License File was corrupted, unable to locate serial`);
}
const endIndex = license.indexOf(endKey, startIndex);
// Slice off the first 4 characters as they are garbage values
return Buffer.from(license.slice(startIndex, endIndex), 'base64').toString('binary').slice(4);
}
}
exports.default = BuildParameters;
/***/ }),
/***/ 97134:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const core = __importStar(__webpack_require__(42186));
const fs_1 = __importDefault(__webpack_require__(35747));
const action_1 = __importDefault(__webpack_require__(89088));
const project_1 = __importDefault(__webpack_require__(88666));
class Cache {
static verify() {
if (!fs_1.default.existsSync(project_1.default.libraryFolder)) {
this.notifyAboutCachingPossibility();
}
}
static notifyAboutCachingPossibility() {
if (action_1.default.isRunningLocally) {
return;
}
core.warning(`
Library folder does not exist.
Consider setting up caching to speed up your workflow,
if this is not your first build.
`);
}
}
exports.default = Cache;
/***/ }),
/***/ 16934:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const exec_1 = __webpack_require__(71514);
const image_tag_1 = __importDefault(__webpack_require__(57648));
class Docker {
static build(buildParameters, silent = false) {
return __awaiter(this, void 0, void 0, function* () {
const { path, dockerfile, baseImage } = buildParameters;
const { version, platform } = baseImage;
const tag = new image_tag_1.default({ repository: '', name: 'unity-builder', version, platform });
const command = `docker build ${path} \
--file ${dockerfile} \
--build-arg IMAGE=${baseImage} \
--tag ${tag}`;
yield exec_1.exec(command, undefined, { silent });
return tag;
});
}
static run(image, parameters, silent = false) {
return __awaiter(this, void 0, void 0, function* () {
const { version, workspace, unitySerial, runnerTempPath, platform, projectPath, buildName, buildPath, buildFile, buildMethod, buildVersion, androidVersionCode, androidKeystoreName, androidKeystoreBase64, androidKeystorePass, androidKeyaliasName, androidKeyaliasPass, androidTargetSdkVersion, androidSdkManagerParameters, customParameters, sshAgent, gitPrivateToken, chownFilesTo, } = parameters;
const baseOsSpecificArguments = this.getBaseOsSpecificArguments(process.platform, workspace, unitySerial, runnerTempPath, sshAgent);
const runCommand = `docker run \
--workdir /github/workspace \
--rm \
--env UNITY_LICENSE \
--env UNITY_LICENSE_FILE \
--env UNITY_EMAIL \
--env UNITY_PASSWORD \
--env UNITY_VERSION="${version}" \
--env USYM_UPLOAD_AUTH_TOKEN \
--env PROJECT_PATH="${projectPath}" \
--env BUILD_TARGET="${platform}" \
--env BUILD_NAME="${buildName}" \
--env BUILD_PATH="${buildPath}" \
--env BUILD_FILE="${buildFile}" \
--env BUILD_METHOD="${buildMethod}" \
--env VERSION="${buildVersion}" \
--env ANDROID_VERSION_CODE="${androidVersionCode}" \
--env ANDROID_KEYSTORE_NAME="${androidKeystoreName}" \
--env ANDROID_KEYSTORE_BASE64="${androidKeystoreBase64}" \
--env ANDROID_KEYSTORE_PASS="${androidKeystorePass}" \
--env ANDROID_KEYALIAS_NAME="${androidKeyaliasName}" \
--env ANDROID_KEYALIAS_PASS="${androidKeyaliasPass}" \
--env ANDROID_TARGET_SDK_VERSION="${androidTargetSdkVersion}" \
--env ANDROID_SDK_MANAGER_PARAMETERS="${androidSdkManagerParameters}" \
--env CUSTOM_PARAMETERS="${customParameters}" \
--env CHOWN_FILES_TO="${chownFilesTo}" \
--env GITHUB_REF \
--env GITHUB_SHA \
--env GITHUB_REPOSITORY \
--env GITHUB_ACTOR \
--env GITHUB_WORKFLOW \
--env GITHUB_HEAD_REF \
--env GITHUB_BASE_REF \
--env GITHUB_EVENT_NAME \
--env GITHUB_WORKSPACE=/github/workspace \
--env GITHUB_ACTION \
--env GITHUB_EVENT_PATH \
--env RUNNER_OS \
--env RUNNER_TOOL_CACHE \
--env RUNNER_TEMP \
--env RUNNER_WORKSPACE \
--env GIT_PRIVATE_TOKEN="${gitPrivateToken}" \
${baseOsSpecificArguments} \
${image}`;
yield exec_1.exec(runCommand, undefined, { silent });
});
}
static getBaseOsSpecificArguments(baseOs, workspace, unitySerial, runnerTemporaryPath, sshAgent) {
switch (baseOs) {
case 'linux':
return `--env UNITY_SERIAL \
${sshAgent ? '--env SSH_AUTH_SOCK=/ssh-agent' : ''} \
--volume "/var/run/docker.sock":"/var/run/docker.sock" \
--volume "${runnerTemporaryPath}/_github_home":"/root" \
--volume "${runnerTemporaryPath}/_github_workflow":"/github/workflow" \
--volume "${workspace}":"/github/workspace" \
${sshAgent ? `--volume ${sshAgent}:/ssh-agent` : ''} \
${sshAgent ? '--volume /home/runner/.ssh/known_hosts:/root/.ssh/known_hosts:ro' : ''}`;
case 'win32':
return `--env UNITY_SERIAL="${unitySerial}" \
--volume "${workspace}":"c:/github/workspace" \
--volume "c:/regkeys":"c:/regkeys" \
--volume "C:/Program Files (x86)/Microsoft Visual Studio":"C:/Program Files (x86)/Microsoft Visual Studio" \
--volume "C:/Program Files (x86)/Windows Kits":"C:/Program Files (x86)/Windows Kits" \
--volume "C:/ProgramData/Microsoft/VisualStudio":"C:/ProgramData/Microsoft/VisualStudio"`;
//Note: When upgrading to Server 2022, we will need to move to just "program files" since VS will be 64-bit
}
return '';
}
}
exports.default = Docker;
/***/ }),
/***/ 26574:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
class NotImplementedException extends Error {
constructor(message = '') {
super(message);
this.name = 'NotImplementedException';
}
}
exports.default = NotImplementedException;
/***/ }),
/***/ 97266:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
class ValidationError extends Error {
constructor(message = '') {
super(message);
this.name = 'ValidationError';
}
}
exports.default = ValidationError;
/***/ }),
/***/ 57648:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const platform_1 = __importDefault(__webpack_require__(9707));
class ImageTag {
constructor(imageProperties) {
const { repository = 'unityci', name = 'editor', version = '2019.2.11f1', platform, customImage } = imageProperties;
if (!ImageTag.versionPattern.test(version)) {
throw new Error(`Invalid version "${version}".`);
}
const builderPlatform = ImageTag.getTargetPlatformToImageSuffixMap(platform, version);
this.repository = repository;
this.name = name;
this.version = version;
this.platform = platform;
this.builderPlatform = builderPlatform;
this.customImage = customImage;
}
static get versionPattern() {
return /^20\d{2}\.\d\.\w{3,4}|3$/;
}
static get imageSuffixes() {
return {
generic: '',
webgl: 'webgl',
mac: 'mac-mono',
windows: 'windows-mono',
windowsIl2cpp: 'windows-il2cpp',
wsaPlayer: 'universal-windows-platform',
linux: 'base',
linuxIl2cpp: 'linux-il2cpp',
android: 'android',
ios: 'ios',
tvos: 'appletv',
facebook: 'facebook',
};
}
static getTargetPlatformToImageSuffixMap(platform, version) {
const { generic, webgl, mac, windows, windowsIl2cpp, wsaPlayer, linux, linuxIl2cpp, android, ios, tvos, facebook, } = ImageTag.imageSuffixes;
const [major, minor] = version.split('.').map((digit) => Number(digit));
// @see: https://docs.unity3d.com/ScriptReference/BuildTarget.html
switch (platform) {
case platform_1.default.types.StandaloneOSX:
return mac;
case platform_1.default.types.StandaloneWindows:
case platform_1.default.types.StandaloneWindows64:
// Can only build windows-il2cpp on a windows based system
if (process.platform === 'win32') {
// Unity versions before 2019.3 do not support il2cpp
if (major >= 2020 || (major === 2019 && minor >= 3)) {
return windowsIl2cpp;
}
else {
throw new Error(`Windows-based builds are only supported on 2019.3.X+ versions of Unity.
If you are trying to build for windows-mono, please use a Linux based OS.`);
}
}
return windows;
case platform_1.default.types.StandaloneLinux64: {
// Unity versions before 2019.3 do not support il2cpp
if (major >= 2020 || (major === 2019 && minor >= 3)) {
return linuxIl2cpp;
}
return linux;
}
case platform_1.default.types.iOS:
return ios;
case platform_1.default.types.Android:
return android;
case platform_1.default.types.WebGL:
return webgl;
case platform_1.default.types.WSAPlayer:
if (process.platform !== 'win32') {
throw new Error(`WSAPlayer can only be built on a windows base OS`);
}
return wsaPlayer;
case platform_1.default.types.PS4:
return windows;
case platform_1.default.types.XboxOne:
return windows;
case platform_1.default.types.tvOS:
if (process.platform !== 'win32') {
throw new Error(`tvOS can only be built on a windows base OS`);
}
return tvos;
case platform_1.default.types.Switch:
return windows;
// Unsupported
case platform_1.default.types.Lumin:
return windows;
case platform_1.default.types.BJM:
return windows;
case platform_1.default.types.Stadia:
return windows;
case platform_1.default.types.Facebook:
return facebook;
case platform_1.default.types.NoTarget:
return generic;
// Test specific
case platform_1.default.types.Test:
return generic;
default:
throw new Error(`
Platform must be one of the ones described in the documentation.
"${platform}" is currently not supported.`);
}
}
get tag() {
//We check the host os so we know what type of the images we need to pull
switch (process.platform) {
case 'win32':
return `windows-${this.version}-${this.builderPlatform}`.replace(/-+$/, '');
case 'linux':
return `${this.version}-${this.builderPlatform}`.replace(/-+$/, '');
default:
break;
}
}
get image() {
return `${this.repository}/${this.name}`.replace(/^\/+/, '');
}
toString() {
const { image, tag, customImage } = this;
if (customImage && customImage !== '') {
return customImage;
}
return `${image}:${tag}-0`; // '0' here represents the docker repo version
}
}
exports.default = ImageTag;
/***/ }),
/***/ 41359:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.RemoteBuilder = exports.Kubernetes = exports.Versioning = exports.Unity = exports.Project = exports.Platform = exports.Output = exports.ImageTag = exports.Input = exports.Docker = exports.Cache = exports.BuildParameters = exports.Action = void 0;
const action_1 = __importDefault(__webpack_require__(89088));
exports.Action = action_1.default;
const build_parameters_1 = __importDefault(__webpack_require__(80787));
exports.BuildParameters = build_parameters_1.default;
const cache_1 = __importDefault(__webpack_require__(97134));
exports.Cache = cache_1.default;
const docker_1 = __importDefault(__webpack_require__(16934));
exports.Docker = docker_1.default;
const input_1 = __importDefault(__webpack_require__(91933));
exports.Input = input_1.default;
const image_tag_1 = __importDefault(__webpack_require__(57648));
exports.ImageTag = image_tag_1.default;
const output_1 = __importDefault(__webpack_require__(85487));
exports.Output = output_1.default;
const platform_1 = __importDefault(__webpack_require__(9707));
exports.Platform = platform_1.default;
const project_1 = __importDefault(__webpack_require__(88666));
exports.Project = project_1.default;
const unity_1 = __importDefault(__webpack_require__(70498));
exports.Unity = unity_1.default;
const versioning_1 = __importDefault(__webpack_require__(88729));
exports.Versioning = versioning_1.default;
const kubernetes_1 = __importDefault(__webpack_require__(7352));
exports.Kubernetes = kubernetes_1.default;
const remote_builder_1 = __importDefault(__webpack_require__(49358));
exports.RemoteBuilder = remote_builder_1.default;
/***/ }),
/***/ 91933:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const platform_1 = __importDefault(__webpack_require__(9707));
const core = __webpack_require__(42186);
/**
* Input variables specified in workflows using "with" prop.
*
* Note that input is always passed as a string, even booleans.
*/
class Input {
static get unityVersion() {
return core.getInput('unityVersion') || 'auto';
}
static get customImage() {
return core.getInput('customImage');
}
static get targetPlatform() {
return core.getInput('targetPlatform') || platform_1.default.default;
}
static get projectPath() {
const rawProjectPath = core.getInput('projectPath') || '.';
return rawProjectPath.replace(/\/$/, '');
}
static get buildName() {
return core.getInput('buildName') || this.targetPlatform;
}
static get buildsPath() {
return core.getInput('buildsPath') || 'build';
}
static get buildMethod() {
return core.getInput('buildMethod'); // processed in docker file
}
static get versioningStrategy() {
return core.getInput('versioning') || 'Semantic';
}
static get specifiedVersion() {
return core.getInput('version') || '';
}
static get androidVersionCode() {
return core.getInput('androidVersionCode');
}
static get androidAppBundle() {
const input = core.getInput('androidAppBundle') || false;
return input === 'true';
}
static get androidKeystoreName() {
return core.getInput('androidKeystoreName') || '';
}
static get androidKeystoreBase64() {
return core.getInput('androidKeystoreBase64') || '';
}
static get androidKeystorePass() {
return core.getInput('androidKeystorePass') || '';
}
static get androidKeyaliasName() {
return core.getInput('androidKeyaliasName') || '';
}
static get androidKeyaliasPass() {
return core.getInput('androidKeyaliasPass') || '';
}
static get androidTargetSdkVersion() {
return core.getInput('androidTargetSdkVersion') || '';
}
static get allowDirtyBuild() {
const input = core.getInput('allowDirtyBuild') || false;
return input === 'true';
}
static get customParameters() {
return core.getInput('customParameters') || '';
}
static get sshAgent() {
return core.getInput('sshAgent') || '';
}
static get gitPrivateToken() {
return core.getInput('gitPrivateToken') || '';
}
static get chownFilesTo() {
return core.getInput('chownFilesTo') || '';
}
static get remoteBuildCluster() {
return core.getInput('remoteBuildCluster') || '';
}
static get awsStackName() {
return core.getInput('awsStackName') || '';
}
static get kubeConfig() {
return core.getInput('kubeConfig') || '';
}
static get githubToken() {
return core.getInput('githubToken') || '';
}
static get remoteBuildMemory() {
return core.getInput('remoteBuildMemory') || '800M';
}
static get remoteBuildCpu() {
return core.getInput('remoteBuildCpu') || '0.25';
}
static get kubeVolumeSize() {
return core.getInput('kubeVolumeSize') || '5Gi';
}
static get kubeVolume() {
return core.getInput('kubeVolume') || '';
}
}
exports.default = Input;
/***/ }),
/***/ 7352:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
// @ts-ignore
const kubernetes_client_1 = __webpack_require__(98862);
const request_1 = __importDefault(__webpack_require__(67002));
const core = __webpack_require__(42186);
const base64 = __webpack_require__(85848);
const pollInterval = 10000;
class Kubernetes {
static runBuildJob(buildParameters, baseImage) {
return __awaiter(this, void 0, void 0, function* () {
const kubeconfig = new kubernetes_client_1.KubeConfig();
kubeconfig.loadFromString(base64.decode(buildParameters.kubeConfig));
const backend = new request_1.default({ kubeconfig });
const kubeClient = new kubernetes_client_1.Client(backend);
yield kubeClient.loadSpec();
const buildId = Kubernetes.uuidv4();
const pvcName = `unity-builder-pvc-${buildId}`;
const secretName = `build-credentials-${buildId}`;
const jobName = `unity-builder-job-${buildId}`;
const namespace = 'default';
this.kubeClient = kubeClient;
this.buildId = buildId;
this.buildParameters = buildParameters;
this.baseImage = baseImage;
this.pvcName = pvcName;
this.secretName = secretName;
this.jobName = jobName;
this.namespace = namespace;
yield Kubernetes.createSecret();
yield Kubernetes.createPersistentVolumeClaim();
yield Kubernetes.scheduleBuildJob();
yield Kubernetes.watchBuildJobUntilFinished();
yield Kubernetes.cleanup();
core.setOutput('volume', pvcName);
});
}
static createSecret() {
return __awaiter(this, void 0, void 0, function* () {
const secretManifest = {
apiVersion: 'v1',
kind: 'Secret',
metadata: {
name: this.secretName,
},
type: 'Opaque',
data: {
GITHUB_TOKEN: base64.encode(this.buildParameters.githubToken),
UNITY_LICENSE: base64.encode(process.env.UNITY_LICENSE),
ANDROID_KEYSTORE_BASE64: base64.encode(this.buildParameters.androidKeystoreBase64),
ANDROID_KEYSTORE_PASS: base64.encode(this.buildParameters.androidKeystorePass),
ANDROID_KEYALIAS_PASS: base64.encode(this.buildParameters.androidKeyaliasPass),
},
};
yield this.kubeClient.api.v1.namespaces(this.namespace).secrets.post({ body: secretManifest });
});
}
static createPersistentVolumeClaim() {
return __awaiter(this, void 0, void 0, function* () {
if (this.buildParameters.kubeVolume) {
core.info(this.buildParameters.kubeVolume);
this.pvcName = this.buildParameters.kubeVolume;
return;
}
const pvcManifest = {
apiVersion: 'v1',
kind: 'PersistentVolumeClaim',
metadata: {
name: this.pvcName,
},
spec: {
accessModes: ['ReadWriteOnce'],
volumeMode: 'Filesystem',
resources: {
requests: {
storage: this.buildParameters.kubeVolumeSize,
},
},
},
};
yield this.kubeClient.api.v1.namespaces(this.namespace).persistentvolumeclaims.post({ body: pvcManifest });
core.info('Persistent Volume created, waiting for ready state...');
yield Kubernetes.watchPersistentVolumeClaimUntilReady();
core.info('Persistent Volume ready for claims');
});
}
static watchPersistentVolumeClaimUntilReady() {
return __awaiter(this, void 0, void 0, function* () {
yield new Promise((resolve) => setTimeout(resolve, pollInterval));
const queryResult = yield this.kubeClient.api.v1
.namespaces(this.namespace)
.persistentvolumeclaims(this.pvcName)
.get();
if (queryResult.body.status.phase === 'Pending') {
yield Kubernetes.watchPersistentVolumeClaimUntilReady();
}
});
}
static scheduleBuildJob() {
return __awaiter(this, void 0, void 0, function* () {
core.info('Creating build job');
const jobManifest = {
apiVersion: 'batch/v1',
kind: 'Job',
metadata: {
name: this.jobName,
labels: {
app: 'unity-builder',
},
},
spec: {
template: {
backoffLimit: 1,
spec: {
volumes: [
{
name: 'data',
persistentVolumeClaim: {
claimName: this.pvcName,
},
},
{
name: 'credentials',
secret: {
secretName: this.secretName,
},
},
],
initContainers: [
{
name: 'clone',
image: 'alpine/git',
command: [
'/bin/sh',
'-c',
`apk update;
apk add git-lfs;
export GITHUB_TOKEN=$(cat /credentials/GITHUB_TOKEN);
cd /data;
git clone https://github.com/${process.env.GITHUB_REPOSITORY}.git repo;
git clone https://github.com/webbertakken/unity-builder.git builder;
cd repo;
git checkout $GITHUB_SHA;
ls`,
],
volumeMounts: [
{
name: 'data',
mountPath: '/data',
},
{
name: 'credentials',
mountPath: '/credentials',
readOnly: true,
},
],
env: [
{
name: 'GITHUB_SHA',
value: this.buildId,
},
],
},
],
containers: [
{
name: 'main',
image: `${this.baseImage.toString()}`,
command: [
'bin/bash',
'-c',
`for f in ./credentials/*; do export $(basename $f)="$(cat $f)"; done
cp -r /data/builder/action/default-build-script /UnityBuilderAction
cp -r /data/builder/action/entrypoint.sh /entrypoint.sh
cp -r /data/builder/action/steps /steps
chmod -R +x /entrypoint.sh;
chmod -R +x /steps;
/entrypoint.sh;
`,
],
resources: {
requests: {
memory: this.buildParameters.kubeContainerMemory,
cpu: this.buildParameters.kubeContainerCPU,
},
},
env: [
{
name: 'GITHUB_WORKSPACE',
value: '/data/repo',
},
{
name: 'PROJECT_PATH',
value: this.buildParameters.projectPath,
},
{
name: 'BUILD_PATH',
value: this.buildParameters.buildPath,
},
{
name: 'BUILD_FILE',
value: this.buildParameters.buildFile,
},
{
name: 'BUILD_NAME',
value: this.buildParameters.buildName,
},
{
name: 'BUILD_METHOD',
value: this.buildParameters.buildMethod,
},
{
name: 'CUSTOM_PARAMETERS',
value: this.buildParameters.customParameters,
},
{
name: 'CHOWN_FILES_TO',
value: this.buildParameters.chownFilesTo,
},
{
name: 'BUILD_TARGET',
value: this.buildParameters.platform,
},
{
name: 'ANDROID_VERSION_CODE',
value: this.buildParameters.androidVersionCode.toString(),
},
{
name: 'ANDROID_KEYSTORE_NAME',
value: this.buildParameters.androidKeystoreName,
},
{
name: 'ANDROID_KEYALIAS_NAME',
value: this.buildParameters.androidKeyaliasName,
},
],
volumeMounts: [
{
name: 'data',
mountPath: '/data',
},
{
name: 'credentials',
mountPath: '/credentials',
readOnly: true,
},
],
lifeCycle: {
preStop: {
exec: {
command: [
'bin/bash',
'-c',
`cd /data/builder/action/steps;
chmod +x /return_license.sh;
/return_license.sh;`,
],
},
},
},
},
],
restartPolicy: 'Never',
},
},
},
};
yield this.kubeClient.apis.batch.v1.namespaces(this.namespace).jobs.post({ body: jobManifest });
core.info('Job created');
});
}
static watchBuildJobUntilFinished() {
return __awaiter(this, void 0, void 0, function* () {
let podname;
let ready = false;
while (!ready) {
yield new Promise((resolve) => setTimeout(resolve, pollInterval));
const pods = yield this.kubeClient.api.v1.namespaces(this.namespace).pods.get();
for (let index = 0; index < pods.body.items.length; index++) {
const element = pods.body.items[index];
if (element.metadata.labels['job-name'] === this.jobName && element.status.phase !== 'Pending') {
core.info('Pod no longer pending');
if (element.status.phase === 'Failure') {
core.error('Kubernetes job failed');
}
else {
ready = true;
podname = element.metadata.name;
}
}
}
}
core.info(`Watching build job ${podname}`);
let logQueryTime;
let complete = false;
while (!complete) {
yield new Promise((resolve) => setTimeout(resolve, pollInterval));
const podStatus = yield this.kubeClient.api.v1.namespaces(this.namespace).pod(podname).get();
if (podStatus.body.status.phase !== 'Running') {
complete = true;
}
const logs = yield this.kubeClient.api.v1
.namespaces(this.namespace)
.pod(podname)
.log.get({
qs: {
sinceTime: logQueryTime,
timestamps: true,
},
});
if (logs.body !== undefined) {
const arrayOfLines = logs.body.match(/[^\n\r]+/g).reverse();
for (const element of arrayOfLines) {
const [time, ...line] = element.split(' ');
if (time !== logQueryTime) {
core.info(line.join(' '));
}
else {
break;
}
}
if (podStatus.body.status.phase === 'Failed') {
throw new Error('Kubernetes job failed');
}
logQueryTime = arrayOfLines[0].split(' ')[0];
}
}
});
}
static cleanup() {
return __awaiter(this, void 0, void 0, function* () {
yield this.kubeClient.apis.batch.v1.namespaces(this.namespace).jobs(this.jobName).delete();
yield this.kubeClient.api.v1.namespaces(this.namespace).secrets(this.secretName).delete();
});
}
static uuidv4() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
const r = Math.trunc(Math.random() * 16);
const v = c === 'x' ? r : (r & 0x3) | 0x8;
return v.toString(16);
});
}
}
exports.default = Kubernetes;
/***/ }),
/***/ 85487:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const core = __webpack_require__(42186);
class Output {
static setBuildVersion(buildVersion) {
return __awaiter(this, void 0, void 0, function* () {
yield core.setOutput('buildVersion', buildVersion);
});
}
}
exports.default = Output;
/***/ }),
/***/ 64423:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const setup_windows_1 = __importDefault(__webpack_require__(37449));
const validate_windows_1 = __importDefault(__webpack_require__(41563));
class PlatformSetup {
static setup(buildParameters) {
return __awaiter(this, void 0, void 0, function* () {
switch (process.platform) {
case 'win32':
validate_windows_1.default.validate(buildParameters);
setup_windows_1.default.setup(buildParameters);
break;
//Add other baseOS's here
}
});
}
}
exports.default = PlatformSetup;
/***/ }),
/***/ 37449:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const exec_1 = __webpack_require__(71514);
const fs_1 = __importDefault(__webpack_require__(35747));
class SetupWindows {
static setup(buildParameters) {
return __awaiter(this, void 0, void 0, function* () {
yield SetupWindows.setupWindowsRun(buildParameters.platform);
});
}
//Setup prerequisite files/folders for a windows-based docker run
static setupWindowsRun(platform, silent = false) {
return __awaiter(this, void 0, void 0, function* () {
if (!fs_1.default.existsSync('c:/regkeys')) {
fs_1.default.mkdirSync('c:/regkeys');
}
switch (platform) {
//These all need the Windows 10 SDK
case 'StandaloneWindows':
case 'StandaloneWindows64':
case 'WSAPlayer':
this.generateWinSDKRegKeys(silent);
break;
}
});
}
static generateWinSDKRegKeys(silent = false) {
return __awaiter(this, void 0, void 0, function* () {
// Export registry keys that point to the location of the windows 10 sdk
const exportWinSDKRegKeysCommand = 'reg export "HKLM\\SOFTWARE\\WOW6432Node\\Microsoft\\Microsoft SDKs\\Windows\\v10.0" c:/regkeys/winsdk.reg /y';
yield exec_1.exec(exportWinSDKRegKeysCommand, undefined, { silent });
});
}
}
exports.default = SetupWindows;
/***/ }),
/***/ 41563:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const fs_1 = __importDefault(__webpack_require__(35747));
class ValidateWindows {
static validate(buildParameters) {
ValidateWindows.validateWindowsPlatformRequirements(buildParameters.platform);
if (!(process.env.UNITY_EMAIL && process.env.UNITY_PASSWORD)) {
throw new Error(`Unity email and password must be set for Windows based builds to
authenticate the license. Make sure to set them inside UNITY_EMAIL
and UNITY_PASSWORD in Github Secrets and pass them into the environment.`);
}
}
static validateWindowsPlatformRequirements(platform) {
switch (platform) {
case 'StandaloneWindows':
this.checkForVisualStudio();
this.checkForWin10SDK();
break;
case 'StandaloneWindows64':
this.checkForVisualStudio();
this.checkForWin10SDK();
break;
case 'WSAPlayer':
this.checkForVisualStudio();
this.checkForWin10SDK();
break;
case 'tvOS':
this.checkForVisualStudio();
break;
}
}
static checkForWin10SDK() {
//Check for Windows 10 SDK on runner
const windows10SDKPathExists = fs_1.default.existsSync('C:/Program Files (x86)/Windows Kits');
if (!windows10SDKPathExists) {
throw new Error(`Windows 10 SDK not found in default location. Make sure
the runner has a Windows 10 SDK installed in the default
location.`);
}
}
static checkForVisualStudio() {
//Note: When upgrading to Server 2022, we will need to move to just "program files" since VS will be 64-bit
const visualStudioInstallPathExists = fs_1.default.existsSync('C:/Program Files (x86)/Microsoft Visual Studio');
const visualStudioDataPathExists = fs_1.default.existsSync('C:/ProgramData/Microsoft/VisualStudio');
if (!visualStudioInstallPathExists || !visualStudioDataPathExists) {
throw new Error(`Visual Studio not found at the default location.
Make sure the runner has Visual Studio installed in the
default location`);
}
}
}
exports.default = ValidateWindows;
/***/ }),
/***/ 9707:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
class Platform {
static get default() {
return Platform.types.StandaloneWindows64;
}
static get types() {
return {
StandaloneOSX: 'StandaloneOSX',
StandaloneWindows: 'StandaloneWindows',
StandaloneWindows64: 'StandaloneWindows64',
StandaloneLinux64: 'StandaloneLinux64',
iOS: 'iOS',
Android: 'Android',
WebGL: 'WebGL',
WSAPlayer: 'WSAPlayer',
PS4: 'PS4',
XboxOne: 'XboxOne',
tvOS: 'tvOS',
Switch: 'Switch',
// Unsupported
Lumin: 'Lumin',
BJM: 'BJM',
Stadia: 'Stadia',
Facebook: 'Facebook',
NoTarget: 'NoTarget',
// Test specific
Test: 'Test',
};
}
static isWindows(platform) {
switch (platform) {
case Platform.types.StandaloneWindows:
case Platform.types.StandaloneWindows64:
return true;
default:
return false;
}
}
static isAndroid(platform) {
switch (platform) {
case Platform.types.Android:
return true;
default:
return false;
}
}
}
exports.default = Platform;
/***/ }),
/***/ 88666:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const input_1 = __importDefault(__webpack_require__(91933));
const unity_1 = __importDefault(__webpack_require__(70498));
const action_1 = __importDefault(__webpack_require__(89088));
class Project {
static get relativePath() {
const { projectPath } = input_1.default;
return `${projectPath}`;
}
static get absolutePath() {
const { workspace } = action_1.default;
return `${workspace}/${this.relativePath}`;
}
static get libraryFolder() {
return `${this.relativePath}/${unity_1.default.libraryFolder}`;
}
}
exports.default = Project;
/***/ }),
/***/ 70187:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const SDK = __importStar(__webpack_require__(71786));
const nanoid_1 = __webpack_require__(39140);
const fs = __importStar(__webpack_require__(35747));
const core = __importStar(__webpack_require__(42186));
const remote_builder_constants_1 = __importDefault(__webpack_require__(92560));
const aws_build_runner_1 = __importDefault(__webpack_require__(11201));
class AWSBuildEnvironment {
static runBuild(buildId, stackName, image, commands, mountdir, workingdir, environment, secrets) {
return __awaiter(this, void 0, void 0, function* () {
const ECS = new SDK.ECS();
const CF = new SDK.CloudFormation();
const entrypoint = ['/bin/sh'];
const taskDef = yield this.setupCloudFormations(CF, buildId, stackName, image, entrypoint, commands, mountdir, workingdir, secrets);
try {
yield aws_build_runner_1.default.runTask(taskDef, ECS, CF, environment, buildId);
}
finally {
yield this.cleanupResources(CF, taskDef);
}
});
}
// static async setupPlatformResources() {
// throw new Error('Method not implemented.');
// }
static getParameterTemplate(p1) {
return `
${p1}:
Type: String
Default: ''
`;
}
static getSecretTemplate(p1) {
return `
${p1}Secret:
Type: AWS::SecretsManager::Secret
Properties:
Name: !Join [ "", [ '${p1}', !Ref BUILDID ] ]
SecretString: !Ref ${p1}
`;
}
static getSecretDefinitionTemplate(p1, p2) {
return `
- Name: '${p1}'
ValueFrom: !Ref ${p2}Secret
`;
}
static insertAtTemplate(template, insertionKey, insertion) {
const index = template.search(insertionKey) + insertionKey.length + '\n'.length;
template = [template.slice(0, index), insertion, template.slice(index)].join('');
return template;
}
static setupCloudFormations(CF, buildUid, stackName, image, entrypoint, commands, mountdir, workingdir, secrets) {
return __awaiter(this, void 0, void 0, function* () {
const logid = nanoid_1.customAlphabet(remote_builder_constants_1.default.alphabet, 9)();
commands[1] += `
echo "${logid}"
`;
const taskDefStackName = `${stackName}-${buildUid}`;
let taskDefCloudFormation = this.readTaskCloudFormationTemplate();
const cleanupTaskDefStackName = `${taskDefStackName}-cleanup`;
const cleanupCloudFormation = fs.readFileSync(`${__dirname}/cloud-formations/cloudformation-stack-ttl.yml`, 'utf8');
try {
for (const secret of secrets) {
taskDefCloudFormation = this.insertAtTemplate(taskDefCloudFormation, 'p1 - input', this.getParameterTemplate(secret.ParameterKey.replace(/[^\dA-Za-z]/g, '')));
taskDefCloudFormation = this.insertAtTemplate(taskDefCloudFormation, 'p2 - secret', this.getSecretTemplate(secret.ParameterKey.replace(/[^\dA-Za-z]/g, '')));
taskDefCloudFormation = this.insertAtTemplate(taskDefCloudFormation, 'p3 - container def', this.getSecretDefinitionTemplate(secret.EnvironmentVariable, secret.ParameterKey.replace(/[^\dA-Za-z]/g, '')));
}
const mappedSecrets = secrets.map((x) => {
return { ParameterKey: x.ParameterKey.replace(/[^\dA-Za-z]/g, ''), ParameterValue: x.ParameterValue };
});
yield CF.createStack({
StackName: taskDefStackName,
TemplateBody: taskDefCloudFormation,
Parameters: [
{
ParameterKey: 'ImageUrl',
ParameterValue: image,
},
{
ParameterKey: 'ServiceName',
ParameterValue: taskDefStackName,
},
{
ParameterKey: 'Command',
ParameterValue: commands.join(','),
},
{
ParameterKey: 'EntryPoint',
ParameterValue: entrypoint.join(','),
},
{
ParameterKey: 'WorkingDirectory',
ParameterValue: workingdir,
},
{
ParameterKey: 'EFSMountDirectory',
ParameterValue: mountdir,
},
{
ParameterKey: 'BUILDID',
ParameterValue: buildUid,
},
...mappedSecrets,
],
}).promise();
core.info('Creating worker cluster...');
yield CF.createStack({
StackName: cleanupTaskDefStackName,
TemplateBody: cleanupCloudFormation,
Capabilities: ['CAPABILITY_IAM'],
Parameters: [
{
ParameterKey: 'StackName',
ParameterValue: taskDefStackName,
},
{
ParameterKey: 'DeleteStackName',
ParameterValue: cleanupTaskDefStackName,
},
{
ParameterKey: 'TTL',
ParameterValue: '100',
},
{
ParameterKey: 'BUILDID',
ParameterValue: buildUid,
},
],
}).promise();
core.info('Creating cleanup cluster...');
yield CF.waitFor('stackCreateComplete', { StackName: taskDefStackName }).promise();
}
catch (error) {
yield AWSBuildEnvironment.handleStackCreationFailure(error, CF, taskDefStackName, taskDefCloudFormation, secrets);
throw error;
}
const taskDefResources = (yield CF.describeStackResources({
StackName: taskDefStackName,
}).promise()).StackResources;
const baseResources = (yield CF.describeStackResources({ StackName: stackName }).promise()).StackResources;
// in the future we should offer a parameter to choose if you want the guarnteed shutdown.
core.info('Worker cluster created successfully (skipping wait for cleanup cluster to be ready)');
return {
taskDefStackName,
taskDefCloudFormation,
taskDefStackNameTTL: cleanupTaskDefStackName,
ttlCloudFormation: cleanupCloudFormation,
taskDefResources,
baseResources,
logid,
};
});
}
static handleStackCreationFailure(error, CF, taskDefStackName, taskDefCloudFormation, secrets) {
return __awaiter(this, void 0, void 0, function* () {
core.info(JSON.stringify(secrets, undefined, 4));
core.info(taskDefCloudFormation);
const events = (yield CF.describeStackEvents({ StackName: taskDefStackName }).promise()).StackEvents;
const resources = (yield CF.describeStackResources({ StackName: taskDefStackName }).promise()).StackResources;
core.info(JSON.stringify(events, undefined, 4));
core.info(JSON.stringify(resources, undefined, 4));
core.error(error);
});
}
static readTaskCloudFormationTemplate() {
return fs.readFileSync(`${__dirname}/cloud-formations/task-def-formation.yml`, 'utf8');
}
static cleanupResources(CF, taskDef) {
return __awaiter(this, void 0, void 0, function* () {
core.info('Cleanup starting');
yield CF.deleteStack({
StackName: taskDef.taskDefStackName,
}).promise();
yield CF.deleteStack({
StackName: taskDef.taskDefStackNameTTL,
}).promise();
yield CF.waitFor('stackDeleteComplete', {
StackName: taskDef.taskDefStackName,
}).promise();
// Currently too slow and causes too much waiting
yield CF.waitFor('stackDeleteComplete', {
StackName: taskDef.taskDefStackNameTTL,
}).promise();
core.info('Cleanup complete');
});
}
}
exports.default = AWSBuildEnvironment;
/***/ }),
/***/ 11201:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const AWS = __importStar(__webpack_require__(71786));
const core = __importStar(__webpack_require__(42186));
const zlib = __importStar(__webpack_require__(78761));
class AWSBuildRunner {
static runTask(taskDef, ECS, CF, environment, buildUid) {
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
return __awaiter(this, void 0, void 0, function* () {
const cluster = ((_b = (_a = taskDef.baseResources) === null || _a === void 0 ? void 0 : _a.find((x) => x.LogicalResourceId === 'ECSCluster')) === null || _b === void 0 ? void 0 : _b.PhysicalResourceId) || '';
const taskDefinition = ((_d = (_c = taskDef.taskDefResources) === null || _c === void 0 ? void 0 : _c.find((x) => x.LogicalResourceId === 'TaskDefinition')) === null || _d === void 0 ? void 0 : _d.PhysicalResourceId) || '';
const SubnetOne = ((_f = (_e = taskDef.baseResources) === null || _e === void 0 ? void 0 : _e.find((x) => x.LogicalResourceId === 'PublicSubnetOne')) === null || _f === void 0 ? void 0 : _f.PhysicalResourceId) || '';
const SubnetTwo = ((_h = (_g = taskDef.baseResources) === null || _g === void 0 ? void 0 : _g.find((x) => x.LogicalResourceId === 'PublicSubnetTwo')) === null || _h === void 0 ? void 0 : _h.PhysicalResourceId) || '';
const ContainerSecurityGroup = ((_k = (_j = taskDef.baseResources) === null || _j === void 0 ? void 0 : _j.find((x) => x.LogicalResourceId === 'ContainerSecurityGroup')) === null || _k === void 0 ? void 0 : _k.PhysicalResourceId) || '';
const streamName = ((_m = (_l = taskDef.taskDefResources) === null || _l === void 0 ? void 0 : _l.find((x) => x.LogicalResourceId === 'KinesisStream')) === null || _m === void 0 ? void 0 : _m.PhysicalResourceId) || '';
const task = yield ECS.runTask({
cluster,
taskDefinition,
platformVersion: '1.4.0',
overrides: {
containerOverrides: [
{
name: taskDef.taskDefStackName,
environment: [...environment, { name: 'BUILDID', value: buildUid }],
},
],
},
launchType: 'FARGATE',
networkConfiguration: {
awsvpcConfiguration: {
subnets: [SubnetOne, SubnetTwo],
assignPublicIp: 'ENABLED',
securityGroups: [ContainerSecurityGroup],
},
},
}).promise();
core.info('Task is starting on worker cluster');
const taskArn = ((_o = task.tasks) === null || _o === void 0 ? void 0 : _o[0].taskArn) || '';
try {
yield ECS.waitFor('tasksRunning', { tasks: [taskArn], cluster }).promise();
}
catch (error) {
yield new Promise((resolve) => setTimeout(resolve, 3000));
const describeTasks = yield ECS.describeTasks({
tasks: [taskArn],
cluster,
}).promise();
core.info(`Task has ended ${(_q = (_p = describeTasks.tasks) === null || _p === void 0 ? void 0 : _p[0].containers) === null || _q === void 0 ? void 0 : _q[0].lastStatus}`);
core.setFailed(error);
core.error(error);
}
core.info(`Task is running on worker cluster`);
yield this.streamLogsUntilTaskStops(ECS, CF, taskDef, cluster, taskArn, streamName);
yield ECS.waitFor('tasksStopped', { cluster, tasks: [taskArn] }).promise();
const exitCode = (_s = (_r = (yield ECS.describeTasks({
tasks: [taskArn],
cluster,
}).promise()).tasks) === null || _r === void 0 ? void 0 : _r[0].containers) === null || _s === void 0 ? void 0 : _s[0].exitCode;
if (exitCode !== 0) {
core.error(`job failed with exit code ${exitCode}`);
throw new Error(`job failed with exit code ${exitCode}`);
}
else {
core.info(`Task has finished successfully`);
}
});
}
static streamLogsUntilTaskStops(ECS, CF, taskDef, clusterName, taskArn, kinesisStreamName) {
var _a;
return __awaiter(this, void 0, void 0, function* () {
// watching logs
const kinesis = new AWS.Kinesis();
const getTaskData = () => __awaiter(this, void 0, void 0, function* () {
var _b;
const tasks = yield ECS.describeTasks({
cluster: clusterName,
tasks: [taskArn],
}).promise();
return (_b = tasks.tasks) === null || _b === void 0 ? void 0 : _b[0];
});
const stream = yield kinesis
.describeStream({
StreamName: kinesisStreamName,
})
.promise();
let iterator = (yield kinesis
.getShardIterator({
ShardIteratorType: 'TRIM_HORIZON',
StreamName: stream.StreamDescription.StreamName,
ShardId: stream.StreamDescription.Shards[0].ShardId,
})
.promise()).ShardIterator || '';
yield CF.waitFor('stackCreateComplete', { StackName: taskDef.taskDefStackNameTTL }).promise();
core.info(`Task status is ${(_a = (yield getTaskData())) === null || _a === void 0 ? void 0 : _a.lastStatus}`);
const logBaseUrl = `https://${AWS.config.region}.console.aws.amazon.com/cloudwatch/home?region=${AWS.config.region}#logsV2:log-groups/log-group/${taskDef.taskDefStackName}`;
core.info(`You can also see the logs at AWS Cloud Watch: ${logBaseUrl}`);
let readingLogs = true;
let timestamp = 0;
while (readingLogs) {
yield new Promise((resolve) => setTimeout(resolve, 1500));
const taskData = yield getTaskData();
if ((taskData === null || taskData === void 0 ? void 0 : taskData.lastStatus) !== 'RUNNING') {
if (timestamp === 0) {
core.info('Task stopped, streaming end of logs');
timestamp = Date.now();
}
if (timestamp !== 0 && Date.now() - timestamp < 30000) {
core.info('Task status is not RUNNING for 30 seconds, last query for logs');
readingLogs = false;
}
}
const records = yield kinesis
.getRecords({
ShardIterator: iterator,
})
.promise();
iterator = records.NextShardIterator || '';
if (records.Records.length > 0 && iterator) {
for (let index = 0; index < records.Records.length; index++) {
const json = JSON.parse(zlib.gunzipSync(Buffer.from(records.Records[index].Data, 'base64')).toString('utf8'));
if (json.messageType === 'DATA_MESSAGE') {
for (let logEventsIndex = 0; logEventsIndex < json.logEvents.length; logEventsIndex++) {
if (json.logEvents[logEventsIndex].message.includes(taskDef.logid)) {
core.info('End of task logs');
readingLogs = false;
}
else {
core.info(json.logEvents[logEventsIndex].message);
}
}
}
}
}
}
});
}
}
exports.default = AWSBuildRunner;
/***/ }),
/***/ 92560:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
class RemoteBuilderConstants {
}
RemoteBuilderConstants.alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
exports.default = RemoteBuilderConstants;
/***/ }),
/***/ 49358:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const nanoid_1 = __webpack_require__(39140);
const aws_build_platform_1 = __importDefault(__webpack_require__(70187));
const core = __importStar(__webpack_require__(42186));
const remote_builder_constants_1 = __importDefault(__webpack_require__(92560));
const repositoryDirectoryName = 'repo';
const efsDirectoryName = 'data';
const cacheDirectoryName = 'cache';
class RemoteBuilder {
static build(buildParameters, baseImage) {
var _a;
return __awaiter(this, void 0, void 0, function* () {
try {
this.SteamDeploy = process.env.STEAM_DEPLOY !== undefined || false;
const nanoid = nanoid_1.customAlphabet(remote_builder_constants_1.default.alphabet, 4);
const buildUid = `${process.env.GITHUB_RUN_NUMBER}-${buildParameters.platform
.replace('Standalone', '')
.replace('standalone', '')}-${nanoid()}`;
const defaultBranchName = ((_a = process.env.GITHUB_REF) === null || _a === void 0 ? void 0 : _a.split('/').filter((x) => {
x = x[0].toUpperCase() + x.slice(1);
return x;
}).join('')) || '';
const branchName = process.env.REMOTE_BUILDER_CACHE !== undefined ? process.env.REMOTE_BUILDER_CACHE : defaultBranchName;
const token = buildParameters.githubToken;
const defaultSecretsArray = [
{
ParameterKey: 'GithubToken',
EnvironmentVariable: 'GITHUB_TOKEN',
ParameterValue: token,
},
];
yield RemoteBuilder.SetupStep(buildUid, buildParameters, branchName, defaultSecretsArray);
yield RemoteBuilder.BuildStep(buildUid, buildParameters, baseImage, defaultSecretsArray);
yield RemoteBuilder.CompressionStep(buildUid, buildParameters, branchName, defaultSecretsArray);
yield RemoteBuilder.UploadArtifacts(buildUid, buildParameters, branchName, defaultSecretsArray);
if (this.SteamDeploy) {
yield RemoteBuilder.DeployToSteam(buildUid, buildParameters, defaultSecretsArray);
}
}
catch (error) {
core.setFailed(error);
core.error(error);
}
});
}
static SetupStep(buildUid, buildParameters, branchName, defaultSecretsArray) {
return __awaiter(this, void 0, void 0, function* () {
core.info('Starting step 1/4 clone and restore cache)');
yield aws_build_platform_1.default.runBuild(buildUid, buildParameters.awsStackName, 'alpine/git', [
'-c',
`apk update;
apk add unzip;
apk add git-lfs;
apk add jq;
# Get source repo for project to be built and game-ci repo for utilties
git clone https://${buildParameters.githubToken}@github.com/${process.env.GITHUB_REPOSITORY}.git ${buildUid}/${repositoryDirectoryName} -q
git clone https://${buildParameters.githubToken}@github.com/game-ci/unity-builder.git ${buildUid}/builder -q
git clone https://${buildParameters.githubToken}@github.com/game-ci/steam-deploy.git ${buildUid}/steam -q
cd /${efsDirectoryName}/${buildUid}/${repositoryDirectoryName}/
git checkout $GITHUB_SHA
cd /${efsDirectoryName}/
# Look for usable cache
if [ ! -d ${cacheDirectoryName} ]; then
mkdir ${cacheDirectoryName}
fi
cd ${cacheDirectoryName}
if [ ! -d "${branchName}" ]; then
mkdir "${branchName}"
fi
cd "${branchName}"
echo ''
echo "Cached Libraries for ${branchName} from previous builds:"
ls
echo ''
ls "/${efsDirectoryName}/${buildUid}/${repositoryDirectoryName}/${buildParameters.projectPath}"
libDir="/${efsDirectoryName}/${buildUid}/${repositoryDirectoryName}/${buildParameters.projectPath}/Library"
if [ -d "$libDir" ]; then
rm -r "$libDir"
echo "Setup .gitignore to ignore Library folder and remove it from builds"
fi
echo 'Checking cache'
# Restore cache
latest=$(ls -t | head -1)
if [ ! -z "$latest" ]; then
echo "Library cache exists from build $latest from ${branchName}"
echo 'Creating empty Library folder for cache'
mkdir $libDir
unzip -q $latest -d $libDir
# purge cache
${process.env.PURGE_REMOTE_BUILDER_CACHE === undefined ? '#' : ''} rm -r $libDir
else
echo 'Cache does not exist'
fi
# Print out important directories
echo ''
echo 'Repo:'
ls /${efsDirectoryName}/${buildUid}/${repositoryDirectoryName}/
echo ''
echo 'Project:'
ls /${efsDirectoryName}/${buildUid}/${repositoryDirectoryName}/${buildParameters.projectPath}
echo ''
echo 'Library:'
ls /${efsDirectoryName}/${buildUid}/${repositoryDirectoryName}/${buildParameters.projectPath}/Library/
echo ''
`,
], `/${efsDirectoryName}`, `/${efsDirectoryName}/`, [
{
name: 'GITHUB_SHA',
value: process.env.GITHUB_SHA || '',
},
], defaultSecretsArray);
});
}
static BuildStep(buildUid, buildParameters, baseImage, defaultSecretsArray) {
return __awaiter(this, void 0, void 0, function* () {
const buildSecrets = new Array();
buildSecrets.push(...defaultSecretsArray);
if (process.env.UNITY_LICENSE)
buildSecrets.push({
ParameterKey: 'UnityLicense',
EnvironmentVariable: 'UNITY_LICENSE',
ParameterValue: process.env.UNITY_LICENSE,
});
if (process.env.UNITY_EMAIL)
buildSecrets.push({
ParameterKey: 'UnityEmail',
EnvironmentVariable: 'UNITY_EMAIL',
ParameterValue: process.env.UNITY_EMAIL,
});
if (process.env.UNITY_PASSWORD)
buildSecrets.push({
ParameterKey: 'UnityPassword',
EnvironmentVariable: 'UNITY_PASSWORD',
ParameterValue: process.env.UNITY_PASSWORD,
});
if (process.env.UNITY_SERIAL)
buildSecrets.push({
ParameterKey: 'UnitySerial',
EnvironmentVariable: 'UNITY_SERIAL',
ParameterValue: process.env.UNITY_SERIAL,
});
if (buildParameters.androidKeystoreBase64)
buildSecrets.push({
ParameterKey: 'AndroidKeystoreBase64',
EnvironmentVariable: 'ANDROID_KEYSTORE_BASE64',
ParameterValue: buildParameters.androidKeystoreBase64,
});
if (buildParameters.androidKeystorePass)
buildSecrets.push({
ParameterKey: 'AndroidKeystorePass',
EnvironmentVariable: 'ANDROID_KEYSTORE_PASS',
ParameterValue: buildParameters.androidKeystorePass,
});
if (buildParameters.androidKeyaliasPass)
buildSecrets.push({
ParameterKey: 'AndroidKeyAliasPass',
EnvironmentVariable: 'AWS_ACCESS_KEY_ALIAS_PASS',
ParameterValue: buildParameters.androidKeyaliasPass,
});
core.info('Starting part 2/4 (build unity project)');
yield aws_build_platform_1.default.runBuild(buildUid, buildParameters.awsStackName, baseImage.toString(), [
'-c',
`
cp -r /${efsDirectoryName}/${buildUid}/builder/dist/default-build-script/ /UnityBuilderAction;
cp -r /${efsDirectoryName}/${buildUid}/builder/dist/entrypoint.sh /entrypoint.sh;
cp -r /${efsDirectoryName}/${buildUid}/builder/dist/steps/ /steps;
chmod -R +x /entrypoint.sh;
chmod -R +x /steps;
/entrypoint.sh;
`,
], `/${efsDirectoryName}`, `/${efsDirectoryName}/${buildUid}/${repositoryDirectoryName}/`, [
{
name: 'ContainerMemory',
value: buildParameters.remoteBuildMemory,
},
{
name: 'ContainerCpu',
value: buildParameters.remoteBuildCpu,
},
{
name: 'GITHUB_WORKSPACE',
value: `/${efsDirectoryName}/${buildUid}/${repositoryDirectoryName}/`,
},
{
name: 'PROJECT_PATH',
value: buildParameters.projectPath,
},
{
name: 'BUILD_PATH',
value: buildParameters.buildPath,
},
{
name: 'BUILD_FILE',
value: buildParameters.buildFile,
},
{
name: 'BUILD_NAME',
value: buildParameters.buildName,
},
{
name: 'BUILD_METHOD',
value: buildParameters.buildMethod,
},
{
name: 'CUSTOM_PARAMETERS',
value: buildParameters.customParameters,
},
{
name: 'BUILD_TARGET',
value: buildParameters.platform,
},
{
name: 'ANDROID_VERSION_CODE',
value: buildParameters.androidVersionCode.toString(),
},
{
name: 'ANDROID_KEYSTORE_NAME',
value: buildParameters.androidKeystoreName,
},
{
name: 'ANDROID_KEYALIAS_NAME',
value: buildParameters.androidKeyaliasName,
},
], buildSecrets);
});
}
static CompressionStep(buildUid, buildParameters, branchName, defaultSecretsArray) {
return __awaiter(this, void 0, void 0, function* () {
core.info('Starting step 3/4 build compression');
// Cleanup
yield aws_build_platform_1.default.runBuild(buildUid, buildParameters.awsStackName, 'alpine', [
'-c',
`
apk update
apk add zip
cd Library
zip -r lib-${buildUid}.zip .*
mv lib-${buildUid}.zip /${efsDirectoryName}/${cacheDirectoryName}/${branchName}/lib-${buildUid}.zip
cd ../../
zip -r build-${buildUid}.zip ${buildParameters.buildPath}/*
mv build-${buildUid}.zip /${efsDirectoryName}/${buildUid}/build-${buildUid}.zip
`,
], `/${efsDirectoryName}`, `/${efsDirectoryName}/${buildUid}/${repositoryDirectoryName}/${buildParameters.projectPath}`, [
{
name: 'GITHUB_SHA',
value: process.env.GITHUB_SHA || '',
},
], defaultSecretsArray);
core.info('compression step complete');
});
}
static UploadArtifacts(buildUid, buildParameters, branchName, defaultSecretsArray) {
return __awaiter(this, void 0, void 0, function* () {
core.info('Starting step 4/4 upload build to s3');
yield aws_build_platform_1.default.runBuild(buildUid, buildParameters.awsStackName, 'amazon/aws-cli', [
'-c',
`
aws s3 cp ${buildUid}/build-${buildUid}.zip s3://game-ci-storage/
# no need to upload Library cache for now
# aws s3 cp /${efsDirectoryName}/${cacheDirectoryName}/${branchName}/lib-${buildUid}.zip s3://game-ci-storage/
${this.SteamDeploy ? '#' : ''} rm -r ${buildUid}
`,
], `/${efsDirectoryName}`, `/${efsDirectoryName}/`, [
{
name: 'GITHUB_SHA',
value: process.env.GITHUB_SHA || '',
},
{
name: 'AWS_DEFAULT_REGION',
value: process.env.AWS_DEFAULT_REGION || '',
},
], [
{
ParameterKey: 'AWSAccessKeyID',
EnvironmentVariable: 'AWS_ACCESS_KEY_ID',
ParameterValue: process.env.AWS_ACCESS_KEY_ID || '',
},
{
ParameterKey: 'AWSSecretAccessKey',
EnvironmentVariable: 'AWS_SECRET_ACCESS_KEY',
ParameterValue: process.env.AWS_SECRET_ACCESS_KEY || '',
},
...defaultSecretsArray,
]);
});
}
static DeployToSteam(buildUid, buildParameters, defaultSecretsArray) {
return __awaiter(this, void 0, void 0, function* () {
core.info('Starting steam deployment');
yield aws_build_platform_1.default.runBuild(buildUid, buildParameters.awsStackName, 'cm2network/steamcmd:root', [
'-c',
`
ls
ls /
cp -r /${efsDirectoryName}/${buildUid}/steam/action/entrypoint.sh /entrypoint.sh;
cp -r /${efsDirectoryName}/${buildUid}/steam/action/steps/ /steps;
chmod -R +x /entrypoint.sh;
chmod -R +x /steps;
/entrypoint.sh;
rm -r /${efsDirectoryName}/${buildUid}
`,
], `/${efsDirectoryName}`, `/${efsDirectoryName}/${buildUid}/steam/action/`, [
{
name: 'GITHUB_SHA',
value: process.env.GITHUB_SHA || '',
},
], [
{
EnvironmentVariable: 'INPUT_APPID',
ParameterKey: 'appId',
ParameterValue: process.env.APP_ID || '',
},
{
EnvironmentVariable: 'INPUT_BUILDDESCRIPTION',
ParameterKey: 'buildDescription',
ParameterValue: process.env.BUILD_DESCRIPTION || '',
},
{
EnvironmentVariable: 'INPUT_ROOTPATH',
ParameterKey: 'rootPath',
ParameterValue: process.env.ROOT_PATH || '',
},
{
EnvironmentVariable: 'INPUT_RELEASEBRANCH',
ParameterKey: 'releaseBranch',
ParameterValue: process.env.RELEASE_BRANCH || '',
},
{
EnvironmentVariable: 'INPUT_LOCALCONTENTSERVER',
ParameterKey: 'localContentServer',
ParameterValue: process.env.LOCAL_CONTENT_SERVER || '',
},
{
EnvironmentVariable: 'INPUT_PREVIEWENABLED',
ParameterKey: 'previewEnabled',
ParameterValue: process.env.PREVIEW_ENABLED || '',
},
...defaultSecretsArray,
]);
});
}
}
RemoteBuilder.SteamDeploy = false;
exports.default = RemoteBuilder;
/***/ }),
/***/ 62177:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const core = __importStar(__webpack_require__(42186));
const exec_1 = __webpack_require__(71514);
class System {
static run(command, arguments_ = [], options = {}) {
return __awaiter(this, void 0, void 0, function* () {
let result = '';
let error = '';
let debug = '';
const listeners = {
stdout: (dataBuffer) => {
result += dataBuffer.toString();
},
stderr: (dataBuffer) => {
error += dataBuffer.toString();
},
debug: (dataString) => {
debug += dataString.toString();
},
};
const showOutput = () => {
if (debug !== '') {
core.debug(debug);
}
if (result !== '') {
core.info(result);
}
if (error !== '') {
core.warning(error);
}
};
const throwContextualError = (message) => {
let commandAsString = command;
if (Array.isArray(arguments_)) {
commandAsString += ` ${arguments_.join(' ')}`;
}
else if (typeof arguments_ === 'string') {
commandAsString += ` ${arguments_}`;
}
throw new Error(`Failed to run "${commandAsString}".\n ${message}`);
};
try {
const exitCode = yield exec_1.exec(command, arguments_, Object.assign({ silent: true, listeners }, options));
showOutput();
if (exitCode !== 0) {
throwContextualError(`Command returned non-zero exit code.\nError: ${error}`);
}
}
catch (inCommandError) {
showOutput();
throwContextualError(`In-command error caught: ${inCommandError}`);
}
return result;
});
}
}
exports.default = System;
/***/ }),
/***/ 17146:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const fs = __importStar(__webpack_require__(35747));
const path_1 = __importDefault(__webpack_require__(85622));
class UnityVersioning {
static get versionPattern() {
return /20\d{2}\.\d\.\w{3,4}|3/;
}
static determineUnityVersion(projectPath, unityVersion) {
if (unityVersion === 'auto') {
return UnityVersioning.read(projectPath);
}
return unityVersion;
}
static read(projectPath) {
const filePath = path_1.default.join(projectPath, 'ProjectSettings', 'ProjectVersion.txt');
if (!fs.existsSync(filePath)) {
throw new Error(`Project settings file not found at "${filePath}". Have you correctly set the projectPath?`);
}
return UnityVersioning.parse(fs.readFileSync(filePath, 'utf8'));
}
static parse(projectVersionTxt) {
const matches = projectVersionTxt.match(UnityVersioning.versionPattern);
if (!matches || matches.length === 0) {
throw new Error(`Failed to parse version from "${projectVersionTxt}".`);
}
return matches[0];
}
}
exports.default = UnityVersioning;
/***/ }),
/***/ 70498:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
class Unity {
static get libraryFolder() {
return 'Library';
}
}
exports.default = Unity;
/***/ }),
/***/ 88729:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const core = __importStar(__webpack_require__(42186));
const not_implemented_exception_1 = __importDefault(__webpack_require__(26574));
const validation_error_1 = __importDefault(__webpack_require__(97266));
const input_1 = __importDefault(__webpack_require__(91933));
const system_1 = __importDefault(__webpack_require__(62177));
class Versioning {
static get projectPath() {
return input_1.default.projectPath;
}
static get isDirtyAllowed() {
return input_1.default.allowDirtyBuild;
}
static get strategies() {
return { None: 'None', Semantic: 'Semantic', Tag: 'Tag', Custom: 'Custom' };
}
/**
* Get the branch name of the (related) branch
*/
static get branch() {
// Todo - use optional chaining (https://github.com/zeit/ncc/issues/534)
return this.headRef || (this.ref && this.ref.slice(11));
}
/**
* For pull requests we can reliably use GITHUB_HEAD_REF
*/
static get headRef() {
return process.env.GITHUB_HEAD_REF;
}
/**
* For branches GITHUB_REF will have format `refs/heads/feature-branch-1`
*/
static get ref() {
return process.env.GITHUB_REF;
}
/**
* The commit SHA that triggered the workflow run.
*/
static get sha() {
return process.env.GITHUB_SHA;
}
/**
* Maximum number of lines to print when logging the git diff
*/
static get maxDiffLines() {
return 60;
}
/**
* Log up to maxDiffLines of the git diff.
*/
static logDiff() {
return __awaiter(this, void 0, void 0, function* () {
const diffCommand = `git --no-pager diff | head -n ${this.maxDiffLines.toString()}`;
yield system_1.default.run('sh', undefined, {
input: Buffer.from(diffCommand),
silent: true,
});
});
}
/**
* Regex to parse version description into separate fields
*/
static get descriptionRegex1() {
return /^v?([\d.]+)-(\d+)-g(\w+)-?(\w+)*/g;
}
static get descriptionRegex2() {
return /^v?([\d.]+-\w+)-(\d+)-g(\w+)-?(\w+)*/g;
}
static get descriptionRegex3() {
return /^v?([\d.]+-\w+\.\d+)-(\d+)-g(\w+)-?(\w+)*/g;
}
static determineVersion(strategy, inputVersion) {
return __awaiter(this, void 0, void 0, function* () {
// Validate input
if (!Object.hasOwnProperty.call(this.strategies, strategy)) {
throw new validation_error_1.default(`Versioning strategy should be one of ${Object.values(this.strategies).join(', ')}.`);
}
let version;
switch (strategy) {
case this.strategies.None:
version = 'none';
break;
case this.strategies.Custom:
version = inputVersion;
break;
case this.strategies.Semantic:
version = yield this.generateSemanticVersion();
break;
case this.strategies.Tag:
version = yield this.generateTagVersion();
break;
default:
throw new not_implemented_exception_1.default(`Strategy ${strategy} is not implemented.`);
}
return version;
});
}
/**
* Automatically generates a version based on SemVer out of the box.
*
* The version works as follows: `..` for example `0.1.2`.
*
* The latest tag dictates `.`
* The number of commits since that tag dictates``.
*
* @See: https://semver.org/
*/
static generateSemanticVersion() {
return __awaiter(this, void 0, void 0, function* () {
if (yield this.isShallow()) {
yield this.fetch();
}
yield this.logDiff();
if ((yield this.isDirty()) && !this.isDirtyAllowed) {
throw new Error('Branch is dirty. Refusing to base semantic version on uncommitted changes');
}
if (!(yield this.hasAnyVersionTags())) {
const version = `0.0.${yield this.getTotalNumberOfCommits()}`;
core.info(`Generated version ${version} (no version tags found).`);
return version;
}
const versionDescriptor = yield this.parseSemanticVersion();
if (versionDescriptor) {
const { tag, commits, hash } = versionDescriptor;
// Ensure 3 digits (commits should always be patch level)
const [major, minor, patch] = `${tag}.${commits}`.split('.');
const threeDigitVersion = /^\d+$/.test(patch) ? `${major}.${minor}.${patch}` : `${major}.0.${minor}`;
core.info(`Found semantic version ${threeDigitVersion} for ${this.branch}@${hash}`);
return `${threeDigitVersion}`;
}
const version = `0.0.${yield this.getTotalNumberOfCommits()}`;
core.info(`Generated version ${version} (semantic version couldn't be determined).`);
return version;
});
}
/**
* Generate the proper version for unity based on an existing tag.
*/
static generateTagVersion() {
return __awaiter(this, void 0, void 0, function* () {
let tag = yield this.getTag();
if (tag.charAt(0) === 'v') {
tag = tag.slice(1);
}
return tag;
});
}
/**
* Parses the versionDescription into their named parts.
*/
static parseSemanticVersion() {
return __awaiter(this, void 0, void 0, function* () {
const description = yield this.getVersionDescription();
try {
const [match, tag, commits, hash] = this.descriptionRegex1.exec(description);
return {
match,
tag,
commits,
hash,
};
}
catch (_a) {
try {
const [match, tag, commits, hash] = this.descriptionRegex2.exec(description);
return {
match,
tag,
commits,
hash,
};
}
catch (_b) {
try {
const [match, tag, commits, hash] = this.descriptionRegex3.exec(description);
return {
match,
tag,
commits,
hash,
};
}
catch (_c) {
core.warning(`Failed to parse git describe output or version can not be determined through: "${description}".`);
return false;
}
}
}
});
}
/**
* Returns whether the repository is shallow.
*/
static isShallow() {
return __awaiter(this, void 0, void 0, function* () {
const output = yield this.git(['rev-parse', '--is-shallow-repository']);
return output !== 'false\n';
});
}
/**
* Retrieves refs from the configured remote.
*
* Fetch unshallow for incomplete repository, but fall back to normal fetch.
*
* Note: `--all` should not be used, and would break fetching for push event.
*/
static fetch() {
return __awaiter(this, void 0, void 0, function* () {
try {
yield this.git(['fetch', '--unshallow']);
}
catch (error) {
core.warning(`Fetch --unshallow caught: ${error}`);
yield this.git(['fetch']);
}
});
}
/**
* Retrieves information about the branch.
*
* Format: `v0.12-24-gd2198ab`
*
* In this format v0.12 is the latest tag, 24 are the number of commits since, and gd2198ab
* identifies the current commit.
*/
static getVersionDescription() {
return __awaiter(this, void 0, void 0, function* () {
return this.git(['describe', '--long', '--tags', '--always', this.sha]);
});
}
/**
* Returns whether there are uncommitted changes that are not ignored.
*/
static isDirty() {
return __awaiter(this, void 0, void 0, function* () {
const output = yield this.git(['status', '--porcelain']);
const isDirty = output !== '';
if (isDirty) {
core.warning('Changes were made to the following files and folders:\n');
core.warning(output);
}
return isDirty;
});
}
/**
* Get the tag if there is one pointing at HEAD
*/
static getTag() {
return __awaiter(this, void 0, void 0, function* () {
return (yield this.git(['tag', '--points-at', 'HEAD'])).trim();
});
}
/**
* Whether or not the repository has any version tags yet.
*/
static hasAnyVersionTags() {
return __awaiter(this, void 0, void 0, function* () {
const numberOfCommitsAsString = yield system_1.default.run('sh', undefined, {
input: Buffer.from('git tag --list --merged HEAD | grep v[0-9]* | wc -l'),
cwd: this.projectPath,
silent: false,
});
const numberOfCommits = Number.parseInt(numberOfCommitsAsString, 10);
return numberOfCommits !== 0;
});
}
/**
* Get the total number of commits on head.
*
* Note: HEAD should not be used, as it may be detached, resulting in an additional count.
*/
static getTotalNumberOfCommits() {
return __awaiter(this, void 0, void 0, function* () {
const numberOfCommitsAsString = yield this.git(['rev-list', '--count', this.sha]);
return Number.parseInt(numberOfCommitsAsString, 10);
});
}
/**
* Run git in the specified project path
*/
static git(arguments_, options = {}) {
return __awaiter(this, void 0, void 0, function* () {
return system_1.default.run('git', arguments_, Object.assign({ cwd: this.projectPath }, options));
});
}
}
exports.default = Versioning;
/***/ }),
/***/ 87351:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result["default"] = mod;
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const os = __importStar(__webpack_require__(12087));
const utils_1 = __webpack_require__(5278);
/**
* Commands
*
* Command Format:
* ::name key=value,key=value::message
*
* Examples:
* ::warning::This is the message
* ::set-env name=MY_VAR::some value
*/
function issueCommand(command, properties, message) {
const cmd = new Command(command, properties, message);
process.stdout.write(cmd.toString() + os.EOL);
}
exports.issueCommand = issueCommand;
function issue(name, message = '') {
issueCommand(name, {}, message);
}
exports.issue = issue;
const CMD_STRING = '::';
class Command {
constructor(command, properties, message) {
if (!command) {
command = 'missing.command';
}
this.command = command;
this.properties = properties;
this.message = message;
}
toString() {
let cmdStr = CMD_STRING + this.command;
if (this.properties && Object.keys(this.properties).length > 0) {
cmdStr += ' ';
let first = true;
for (const key in this.properties) {
if (this.properties.hasOwnProperty(key)) {
const val = this.properties[key];
if (val) {
if (first) {
first = false;
}
else {
cmdStr += ',';
}
cmdStr += `${key}=${escapeProperty(val)}`;
}
}
}
}
cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
return cmdStr;
}
}
function escapeData(s) {
return utils_1.toCommandValue(s)
.replace(/%/g, '%25')
.replace(/\r/g, '%0D')
.replace(/\n/g, '%0A');
}
function escapeProperty(s) {
return utils_1.toCommandValue(s)
.replace(/%/g, '%25')
.replace(/\r/g, '%0D')
.replace(/\n/g, '%0A')
.replace(/:/g, '%3A')
.replace(/,/g, '%2C');
}
//# sourceMappingURL=command.js.map
/***/ }),
/***/ 42186:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result["default"] = mod;
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const command_1 = __webpack_require__(87351);
const file_command_1 = __webpack_require__(717);
const utils_1 = __webpack_require__(5278);
const os = __importStar(__webpack_require__(12087));
const path = __importStar(__webpack_require__(85622));
/**
* The code to exit an action
*/
var ExitCode;
(function (ExitCode) {
/**
* A code indicating that the action was successful
*/
ExitCode[ExitCode["Success"] = 0] = "Success";
/**
* A code indicating that the action was a failure
*/
ExitCode[ExitCode["Failure"] = 1] = "Failure";
})(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
//-----------------------------------------------------------------------
// Variables
//-----------------------------------------------------------------------
/**
* Sets env variable for this action and future actions in the job
* @param name the name of the variable to set
* @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function exportVariable(name, val) {
const convertedVal = utils_1.toCommandValue(val);
process.env[name] = convertedVal;
const filePath = process.env['GITHUB_ENV'] || '';
if (filePath) {
const delimiter = '_GitHubActionsFileCommandDelimeter_';
const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`;
file_command_1.issueCommand('ENV', commandValue);
}
else {
command_1.issueCommand('set-env', { name }, convertedVal);
}
}
exports.exportVariable = exportVariable;
/**
* Registers a secret which will get masked from logs
* @param secret value of the secret
*/
function setSecret(secret) {
command_1.issueCommand('add-mask', {}, secret);
}
exports.setSecret = setSecret;
/**
* Prepends inputPath to the PATH (for this action and future actions)
* @param inputPath
*/
function addPath(inputPath) {
const filePath = process.env['GITHUB_PATH'] || '';
if (filePath) {
file_command_1.issueCommand('PATH', inputPath);
}
else {
command_1.issueCommand('add-path', {}, inputPath);
}
process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
}
exports.addPath = addPath;
/**
* Gets the value of an input. The value is also trimmed.
*
* @param name name of the input to get
* @param options optional. See InputOptions.
* @returns string
*/
function getInput(name, options) {
const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
if (options && options.required && !val) {
throw new Error(`Input required and not supplied: ${name}`);
}
return val.trim();
}
exports.getInput = getInput;
/**
* Sets the value of an output.
*
* @param name name of the output to set
* @param value value to store. Non-string values will be converted to a string via JSON.stringify
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function setOutput(name, value) {
process.stdout.write(os.EOL);
command_1.issueCommand('set-output', { name }, value);
}
exports.setOutput = setOutput;
/**
* Enables or disables the echoing of commands into stdout for the rest of the step.
* Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
*
*/
function setCommandEcho(enabled) {
command_1.issue('echo', enabled ? 'on' : 'off');
}
exports.setCommandEcho = setCommandEcho;
//-----------------------------------------------------------------------
// Results
//-----------------------------------------------------------------------
/**
* Sets the action status to failed.
* When the action exits it will be with an exit code of 1
* @param message add error issue message
*/
function setFailed(message) {
process.exitCode = ExitCode.Failure;
error(message);
}
exports.setFailed = setFailed;
//-----------------------------------------------------------------------
// Logging Commands
//-----------------------------------------------------------------------
/**
* Gets whether Actions Step Debug is on or not
*/
function isDebug() {
return process.env['RUNNER_DEBUG'] === '1';
}
exports.isDebug = isDebug;
/**
* Writes debug message to user log
* @param message debug message
*/
function debug(message) {
command_1.issueCommand('debug', {}, message);
}
exports.debug = debug;
/**
* Adds an error issue
* @param message error issue message. Errors will be converted to string via toString()
*/
function error(message) {
command_1.issue('error', message instanceof Error ? message.toString() : message);
}
exports.error = error;
/**
* Adds an warning issue
* @param message warning issue message. Errors will be converted to string via toString()
*/
function warning(message) {
command_1.issue('warning', message instanceof Error ? message.toString() : message);
}
exports.warning = warning;
/**
* Writes info to log with console.log.
* @param message info message
*/
function info(message) {
process.stdout.write(message + os.EOL);
}
exports.info = info;
/**
* Begin an output group.
*
* Output until the next `groupEnd` will be foldable in this group
*
* @param name The name of the output group
*/
function startGroup(name) {
command_1.issue('group', name);
}
exports.startGroup = startGroup;
/**
* End an output group.
*/
function endGroup() {
command_1.issue('endgroup');
}
exports.endGroup = endGroup;
/**
* Wrap an asynchronous function call in a group.
*
* Returns the same type as the function itself.
*
* @param name The name of the group
* @param fn The function to wrap in the group
*/
function group(name, fn) {
return __awaiter(this, void 0, void 0, function* () {
startGroup(name);
let result;
try {
result = yield fn();
}
finally {
endGroup();
}
return result;
});
}
exports.group = group;
//-----------------------------------------------------------------------
// Wrapper action state
//-----------------------------------------------------------------------
/**
* Saves state for current action, the state can only be retrieved by this action's post job execution.
*
* @param name name of the state to store
* @param value value to store. Non-string values will be converted to a string via JSON.stringify
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function saveState(name, value) {
command_1.issueCommand('save-state', { name }, value);
}
exports.saveState = saveState;
/**
* Gets the value of an state set by this action's main execution.
*
* @param name name of the state to get
* @returns string
*/
function getState(name) {
return process.env[`STATE_${name}`] || '';
}
exports.getState = getState;
//# sourceMappingURL=core.js.map
/***/ }),
/***/ 717:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
// For internal use, subject to change.
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result["default"] = mod;
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
// We use any as a valid input type
/* eslint-disable @typescript-eslint/no-explicit-any */
const fs = __importStar(__webpack_require__(35747));
const os = __importStar(__webpack_require__(12087));
const utils_1 = __webpack_require__(5278);
function issueCommand(command, message) {
const filePath = process.env[`GITHUB_${command}`];
if (!filePath) {
throw new Error(`Unable to find environment variable for file command ${command}`);
}
if (!fs.existsSync(filePath)) {
throw new Error(`Missing file at path: ${filePath}`);
}
fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, {
encoding: 'utf8'
});
}
exports.issueCommand = issueCommand;
//# sourceMappingURL=file-command.js.map
/***/ }),
/***/ 5278:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
// We use any as a valid input type
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, "__esModule", ({ value: true }));
/**
* Sanitizes an input into a string so it can be passed into issueCommand safely
* @param input input to sanitize into a string
*/
function toCommandValue(input) {
if (input === null || input === undefined) {
return '';
}
else if (typeof input === 'string' || input instanceof String) {
return input;
}
return JSON.stringify(input);
}
exports.toCommandValue = toCommandValue;
//# sourceMappingURL=utils.js.map
/***/ }),
/***/ 71514:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result["default"] = mod;
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const tr = __importStar(__webpack_require__(88159));
/**
* Exec a command.
* Output will be streamed to the live console.
* Returns promise with return code
*
* @param commandLine command to execute (can include additional args). Must be correctly escaped.
* @param args optional arguments for tool. Escaping is handled by the lib.
* @param options optional exec options. See ExecOptions
* @returns Promise exit code
*/
function exec(commandLine, args, options) {
return __awaiter(this, void 0, void 0, function* () {
const commandArgs = tr.argStringToArray(commandLine);
if (commandArgs.length === 0) {
throw new Error(`Parameter 'commandLine' cannot be null or empty.`);
}
// Path to tool to execute should be first arg
const toolPath = commandArgs[0];
args = commandArgs.slice(1).concat(args || []);
const runner = new tr.ToolRunner(toolPath, args, options);
return runner.exec();
});
}
exports.exec = exec;
//# sourceMappingURL=exec.js.map
/***/ }),
/***/ 88159:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result["default"] = mod;
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const os = __importStar(__webpack_require__(12087));
const events = __importStar(__webpack_require__(28614));
const child = __importStar(__webpack_require__(63129));
const path = __importStar(__webpack_require__(85622));
const io = __importStar(__webpack_require__(47351));
const ioUtil = __importStar(__webpack_require__(81962));
/* eslint-disable @typescript-eslint/unbound-method */
const IS_WINDOWS = process.platform === 'win32';
/*
* Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way.
*/
class ToolRunner extends events.EventEmitter {
constructor(toolPath, args, options) {
super();
if (!toolPath) {
throw new Error("Parameter 'toolPath' cannot be null or empty.");
}
this.toolPath = toolPath;
this.args = args || [];
this.options = options || {};
}
_debug(message) {
if (this.options.listeners && this.options.listeners.debug) {
this.options.listeners.debug(message);
}
}
_getCommandString(options, noPrefix) {
const toolPath = this._getSpawnFileName();
const args = this._getSpawnArgs(options);
let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool
if (IS_WINDOWS) {
// Windows + cmd file
if (this._isCmdFile()) {
cmd += toolPath;
for (const a of args) {
cmd += ` ${a}`;
}
}
// Windows + verbatim
else if (options.windowsVerbatimArguments) {
cmd += `"${toolPath}"`;
for (const a of args) {
cmd += ` ${a}`;
}
}
// Windows (regular)
else {
cmd += this._windowsQuoteCmdArg(toolPath);
for (const a of args) {
cmd += ` ${this._windowsQuoteCmdArg(a)}`;
}
}
}
else {
// OSX/Linux - this can likely be improved with some form of quoting.
// creating processes on Unix is fundamentally different than Windows.
// on Unix, execvp() takes an arg array.
cmd += toolPath;
for (const a of args) {
cmd += ` ${a}`;
}
}
return cmd;
}
_processLineBuffer(data, strBuffer, onLine) {
try {
let s = strBuffer + data.toString();
let n = s.indexOf(os.EOL);
while (n > -1) {
const line = s.substring(0, n);
onLine(line);
// the rest of the string ...
s = s.substring(n + os.EOL.length);
n = s.indexOf(os.EOL);
}
strBuffer = s;
}
catch (err) {
// streaming lines to console is best effort. Don't fail a build.
this._debug(`error processing line. Failed with error ${err}`);
}
}
_getSpawnFileName() {
if (IS_WINDOWS) {
if (this._isCmdFile()) {
return process.env['COMSPEC'] || 'cmd.exe';
}
}
return this.toolPath;
}
_getSpawnArgs(options) {
if (IS_WINDOWS) {
if (this._isCmdFile()) {
let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`;
for (const a of this.args) {
argline += ' ';
argline += options.windowsVerbatimArguments
? a
: this._windowsQuoteCmdArg(a);
}
argline += '"';
return [argline];
}
}
return this.args;
}
_endsWith(str, end) {
return str.endsWith(end);
}
_isCmdFile() {
const upperToolPath = this.toolPath.toUpperCase();
return (this._endsWith(upperToolPath, '.CMD') ||
this._endsWith(upperToolPath, '.BAT'));
}
_windowsQuoteCmdArg(arg) {
// for .exe, apply the normal quoting rules that libuv applies
if (!this._isCmdFile()) {
return this._uvQuoteCmdArg(arg);
}
// otherwise apply quoting rules specific to the cmd.exe command line parser.
// the libuv rules are generic and are not designed specifically for cmd.exe
// command line parser.
//
// for a detailed description of the cmd.exe command line parser, refer to
// http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912
// need quotes for empty arg
if (!arg) {
return '""';
}
// determine whether the arg needs to be quoted
const cmdSpecialChars = [
' ',
'\t',
'&',
'(',
')',
'[',
']',
'{',
'}',
'^',
'=',
';',
'!',
"'",
'+',
',',
'`',
'~',
'|',
'<',
'>',
'"'
];
let needsQuotes = false;
for (const char of arg) {
if (cmdSpecialChars.some(x => x === char)) {
needsQuotes = true;
break;
}
}
// short-circuit if quotes not needed
if (!needsQuotes) {
return arg;
}
// the following quoting rules are very similar to the rules that by libuv applies.
//
// 1) wrap the string in quotes
//
// 2) double-up quotes - i.e. " => ""
//
// this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately
// doesn't work well with a cmd.exe command line.
//
// note, replacing " with "" also works well if the arg is passed to a downstream .NET console app.
// for example, the command line:
// foo.exe "myarg:""my val"""
// is parsed by a .NET console app into an arg array:
// [ "myarg:\"my val\"" ]
// which is the same end result when applying libuv quoting rules. although the actual
// command line from libuv quoting rules would look like:
// foo.exe "myarg:\"my val\""
//
// 3) double-up slashes that precede a quote,
// e.g. hello \world => "hello \world"
// hello\"world => "hello\\""world"
// hello\\"world => "hello\\\\""world"
// hello world\ => "hello world\\"
//
// technically this is not required for a cmd.exe command line, or the batch argument parser.
// the reasons for including this as a .cmd quoting rule are:
//
// a) this is optimized for the scenario where the argument is passed from the .cmd file to an
// external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule.
//
// b) it's what we've been doing previously (by deferring to node default behavior) and we
// haven't heard any complaints about that aspect.
//
// note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be
// escaped when used on the command line directly - even though within a .cmd file % can be escaped
// by using %%.
//
// the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts
// the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing.
//
// one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would
// often work, since it is unlikely that var^ would exist, and the ^ character is removed when the
// variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args
// to an external program.
//
// an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file.
// % can be escaped within a .cmd file.
let reverse = '"';
let quoteHit = true;
for (let i = arg.length; i > 0; i--) {
// walk the string in reverse
reverse += arg[i - 1];
if (quoteHit && arg[i - 1] === '\\') {
reverse += '\\'; // double the slash
}
else if (arg[i - 1] === '"') {
quoteHit = true;
reverse += '"'; // double the quote
}
else {
quoteHit = false;
}
}
reverse += '"';
return reverse
.split('')
.reverse()
.join('');
}
_uvQuoteCmdArg(arg) {
// Tool runner wraps child_process.spawn() and needs to apply the same quoting as
// Node in certain cases where the undocumented spawn option windowsVerbatimArguments
// is used.
//
// Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV,
// see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details),
// pasting copyright notice from Node within this function:
//
// Copyright Joyent, Inc. and other Node contributors. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
if (!arg) {
// Need double quotation for empty argument
return '""';
}
if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) {
// No quotation needed
return arg;
}
if (!arg.includes('"') && !arg.includes('\\')) {
// No embedded double quotes or backslashes, so I can just wrap
// quote marks around the whole thing.
return `"${arg}"`;
}
// Expected input/output:
// input : hello"world
// output: "hello\"world"
// input : hello""world
// output: "hello\"\"world"
// input : hello\world
// output: hello\world
// input : hello\\world
// output: hello\\world
// input : hello\"world
// output: "hello\\\"world"
// input : hello\\"world
// output: "hello\\\\\"world"
// input : hello world\
// output: "hello world\\" - note the comment in libuv actually reads "hello world\"
// but it appears the comment is wrong, it should be "hello world\\"
let reverse = '"';
let quoteHit = true;
for (let i = arg.length; i > 0; i--) {
// walk the string in reverse
reverse += arg[i - 1];
if (quoteHit && arg[i - 1] === '\\') {
reverse += '\\';
}
else if (arg[i - 1] === '"') {
quoteHit = true;
reverse += '\\';
}
else {
quoteHit = false;
}
}
reverse += '"';
return reverse
.split('')
.reverse()
.join('');
}
_cloneExecOptions(options) {
options = options || {};
const result = {
cwd: options.cwd || process.cwd(),
env: options.env || process.env,
silent: options.silent || false,
windowsVerbatimArguments: options.windowsVerbatimArguments || false,
failOnStdErr: options.failOnStdErr || false,
ignoreReturnCode: options.ignoreReturnCode || false,
delay: options.delay || 10000
};
result.outStream = options.outStream || process.stdout;
result.errStream = options.errStream || process.stderr;
return result;
}
_getSpawnOptions(options, toolPath) {
options = options || {};
const result = {};
result.cwd = options.cwd;
result.env = options.env;
result['windowsVerbatimArguments'] =
options.windowsVerbatimArguments || this._isCmdFile();
if (options.windowsVerbatimArguments) {
result.argv0 = `"${toolPath}"`;
}
return result;
}
/**
* Exec a tool.
* Output will be streamed to the live console.
* Returns promise with return code
*
* @param tool path to tool to exec
* @param options optional exec options. See ExecOptions
* @returns number
*/
exec() {
return __awaiter(this, void 0, void 0, function* () {
// root the tool path if it is unrooted and contains relative pathing
if (!ioUtil.isRooted(this.toolPath) &&
(this.toolPath.includes('/') ||
(IS_WINDOWS && this.toolPath.includes('\\')))) {
// prefer options.cwd if it is specified, however options.cwd may also need to be rooted
this.toolPath = path.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
}
// if the tool is only a file name, then resolve it from the PATH
// otherwise verify it exists (add extension on Windows if necessary)
this.toolPath = yield io.which(this.toolPath, true);
return new Promise((resolve, reject) => {
this._debug(`exec tool: ${this.toolPath}`);
this._debug('arguments:');
for (const arg of this.args) {
this._debug(` ${arg}`);
}
const optionsNonNull = this._cloneExecOptions(this.options);
if (!optionsNonNull.silent && optionsNonNull.outStream) {
optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL);
}
const state = new ExecState(optionsNonNull, this.toolPath);
state.on('debug', (message) => {
this._debug(message);
});
const fileName = this._getSpawnFileName();
const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName));
const stdbuffer = '';
if (cp.stdout) {
cp.stdout.on('data', (data) => {
if (this.options.listeners && this.options.listeners.stdout) {
this.options.listeners.stdout(data);
}
if (!optionsNonNull.silent && optionsNonNull.outStream) {
optionsNonNull.outStream.write(data);
}
this._processLineBuffer(data, stdbuffer, (line) => {
if (this.options.listeners && this.options.listeners.stdline) {
this.options.listeners.stdline(line);
}
});
});
}
const errbuffer = '';
if (cp.stderr) {
cp.stderr.on('data', (data) => {
state.processStderr = true;
if (this.options.listeners && this.options.listeners.stderr) {
this.options.listeners.stderr(data);
}
if (!optionsNonNull.silent &&
optionsNonNull.errStream &&
optionsNonNull.outStream) {
const s = optionsNonNull.failOnStdErr
? optionsNonNull.errStream
: optionsNonNull.outStream;
s.write(data);
}
this._processLineBuffer(data, errbuffer, (line) => {
if (this.options.listeners && this.options.listeners.errline) {
this.options.listeners.errline(line);
}
});
});
}
cp.on('error', (err) => {
state.processError = err.message;
state.processExited = true;
state.processClosed = true;
state.CheckComplete();
});
cp.on('exit', (code) => {
state.processExitCode = code;
state.processExited = true;
this._debug(`Exit code ${code} received from tool '${this.toolPath}'`);
state.CheckComplete();
});
cp.on('close', (code) => {
state.processExitCode = code;
state.processExited = true;
state.processClosed = true;
this._debug(`STDIO streams have closed for tool '${this.toolPath}'`);
state.CheckComplete();
});
state.on('done', (error, exitCode) => {
if (stdbuffer.length > 0) {
this.emit('stdline', stdbuffer);
}
if (errbuffer.length > 0) {
this.emit('errline', errbuffer);
}
cp.removeAllListeners();
if (error) {
reject(error);
}
else {
resolve(exitCode);
}
});
if (this.options.input) {
if (!cp.stdin) {
throw new Error('child process missing stdin');
}
cp.stdin.end(this.options.input);
}
});
});
}
}
exports.ToolRunner = ToolRunner;
/**
* Convert an arg string to an array of args. Handles escaping
*
* @param argString string of arguments
* @returns string[] array of arguments
*/
function argStringToArray(argString) {
const args = [];
let inQuotes = false;
let escaped = false;
let arg = '';
function append(c) {
// we only escape double quotes.
if (escaped && c !== '"') {
arg += '\\';
}
arg += c;
escaped = false;
}
for (let i = 0; i < argString.length; i++) {
const c = argString.charAt(i);
if (c === '"') {
if (!escaped) {
inQuotes = !inQuotes;
}
else {
append(c);
}
continue;
}
if (c === '\\' && escaped) {
append(c);
continue;
}
if (c === '\\' && inQuotes) {
escaped = true;
continue;
}
if (c === ' ' && !inQuotes) {
if (arg.length > 0) {
args.push(arg);
arg = '';
}
continue;
}
append(c);
}
if (arg.length > 0) {
args.push(arg.trim());
}
return args;
}
exports.argStringToArray = argStringToArray;
class ExecState extends events.EventEmitter {
constructor(options, toolPath) {
super();
this.processClosed = false; // tracks whether the process has exited and stdio is closed
this.processError = '';
this.processExitCode = 0;
this.processExited = false; // tracks whether the process has exited
this.processStderr = false; // tracks whether stderr was written to
this.delay = 10000; // 10 seconds
this.done = false;
this.timeout = null;
if (!toolPath) {
throw new Error('toolPath must not be empty');
}
this.options = options;
this.toolPath = toolPath;
if (options.delay) {
this.delay = options.delay;
}
}
CheckComplete() {
if (this.done) {
return;
}
if (this.processClosed) {
this._setResult();
}
else if (this.processExited) {
this.timeout = setTimeout(ExecState.HandleTimeout, this.delay, this);
}
}
_debug(message) {
this.emit('debug', message);
}
_setResult() {
// determine whether there is an error
let error;
if (this.processExited) {
if (this.processError) {
error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`);
}
else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) {
error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`);
}
else if (this.processStderr && this.options.failOnStdErr) {
error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`);
}
}
// clear the timeout
if (this.timeout) {
clearTimeout(this.timeout);
this.timeout = null;
}
this.done = true;
this.emit('done', error, this.processExitCode);
}
static HandleTimeout(state) {
if (state.done) {
return;
}
if (!state.processClosed && state.processExited) {
const message = `The STDIO streams did not close within ${state.delay /
1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`;
state._debug(message);
}
state._setResult();
}
}
//# sourceMappingURL=toolrunner.js.map
/***/ }),
/***/ 81962:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result["default"] = mod;
return result;
};
var _a;
Object.defineProperty(exports, "__esModule", ({ value: true }));
const assert_1 = __webpack_require__(42357);
const fs = __importStar(__webpack_require__(35747));
const path = __importStar(__webpack_require__(85622));
_a = fs.promises, exports.chmod = _a.chmod, exports.copyFile = _a.copyFile, exports.lstat = _a.lstat, exports.mkdir = _a.mkdir, exports.readdir = _a.readdir, exports.readlink = _a.readlink, exports.rename = _a.rename, exports.rmdir = _a.rmdir, exports.stat = _a.stat, exports.symlink = _a.symlink, exports.unlink = _a.unlink;
exports.IS_WINDOWS = process.platform === 'win32';
function exists(fsPath) {
return __awaiter(this, void 0, void 0, function* () {
try {
yield exports.stat(fsPath);
}
catch (err) {
if (err.code === 'ENOENT') {
return false;
}
throw err;
}
return true;
});
}
exports.exists = exists;
function isDirectory(fsPath, useStat = false) {
return __awaiter(this, void 0, void 0, function* () {
const stats = useStat ? yield exports.stat(fsPath) : yield exports.lstat(fsPath);
return stats.isDirectory();
});
}
exports.isDirectory = isDirectory;
/**
* On OSX/Linux, true if path starts with '/'. On Windows, true for paths like:
* \, \hello, \\hello\share, C:, and C:\hello (and corresponding alternate separator cases).
*/
function isRooted(p) {
p = normalizeSeparators(p);
if (!p) {
throw new Error('isRooted() parameter "p" cannot be empty');
}
if (exports.IS_WINDOWS) {
return (p.startsWith('\\') || /^[A-Z]:/i.test(p) // e.g. \ or \hello or \\hello
); // e.g. C: or C:\hello
}
return p.startsWith('/');
}
exports.isRooted = isRooted;
/**
* Recursively create a directory at `fsPath`.
*
* This implementation is optimistic, meaning it attempts to create the full
* path first, and backs up the path stack from there.
*
* @param fsPath The path to create
* @param maxDepth The maximum recursion depth
* @param depth The current recursion depth
*/
function mkdirP(fsPath, maxDepth = 1000, depth = 1) {
return __awaiter(this, void 0, void 0, function* () {
assert_1.ok(fsPath, 'a path argument must be provided');
fsPath = path.resolve(fsPath);
if (depth >= maxDepth)
return exports.mkdir(fsPath);
try {
yield exports.mkdir(fsPath);
return;
}
catch (err) {
switch (err.code) {
case 'ENOENT': {
yield mkdirP(path.dirname(fsPath), maxDepth, depth + 1);
yield exports.mkdir(fsPath);
return;
}
default: {
let stats;
try {
stats = yield exports.stat(fsPath);
}
catch (err2) {
throw err;
}
if (!stats.isDirectory())
throw err;
}
}
}
});
}
exports.mkdirP = mkdirP;
/**
* Best effort attempt to determine whether a file exists and is executable.
* @param filePath file path to check
* @param extensions additional file extensions to try
* @return if file exists and is executable, returns the file path. otherwise empty string.
*/
function tryGetExecutablePath(filePath, extensions) {
return __awaiter(this, void 0, void 0, function* () {
let stats = undefined;
try {
// test file exists
stats = yield exports.stat(filePath);
}
catch (err) {
if (err.code !== 'ENOENT') {
// eslint-disable-next-line no-console
console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
}
}
if (stats && stats.isFile()) {
if (exports.IS_WINDOWS) {
// on Windows, test for valid extension
const upperExt = path.extname(filePath).toUpperCase();
if (extensions.some(validExt => validExt.toUpperCase() === upperExt)) {
return filePath;
}
}
else {
if (isUnixExecutable(stats)) {
return filePath;
}
}
}
// try each extension
const originalFilePath = filePath;
for (const extension of extensions) {
filePath = originalFilePath + extension;
stats = undefined;
try {
stats = yield exports.stat(filePath);
}
catch (err) {
if (err.code !== 'ENOENT') {
// eslint-disable-next-line no-console
console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
}
}
if (stats && stats.isFile()) {
if (exports.IS_WINDOWS) {
// preserve the case of the actual file (since an extension was appended)
try {
const directory = path.dirname(filePath);
const upperName = path.basename(filePath).toUpperCase();
for (const actualName of yield exports.readdir(directory)) {
if (upperName === actualName.toUpperCase()) {
filePath = path.join(directory, actualName);
break;
}
}
}
catch (err) {
// eslint-disable-next-line no-console
console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`);
}
return filePath;
}
else {
if (isUnixExecutable(stats)) {
return filePath;
}
}
}
}
return '';
});
}
exports.tryGetExecutablePath = tryGetExecutablePath;
function normalizeSeparators(p) {
p = p || '';
if (exports.IS_WINDOWS) {
// convert slashes on Windows
p = p.replace(/\//g, '\\');
// remove redundant slashes
return p.replace(/\\\\+/g, '\\');
}
// remove redundant slashes
return p.replace(/\/\/+/g, '/');
}
// on Mac/Linux, test the execute bit
// R W X R W X R W X
// 256 128 64 32 16 8 4 2 1
function isUnixExecutable(stats) {
return ((stats.mode & 1) > 0 ||
((stats.mode & 8) > 0 && stats.gid === process.getgid()) ||
((stats.mode & 64) > 0 && stats.uid === process.getuid()));
}
//# sourceMappingURL=io-util.js.map
/***/ }),
/***/ 47351:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result["default"] = mod;
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
const childProcess = __importStar(__webpack_require__(63129));
const path = __importStar(__webpack_require__(85622));
const util_1 = __webpack_require__(31669);
const ioUtil = __importStar(__webpack_require__(81962));
const exec = util_1.promisify(childProcess.exec);
/**
* Copies a file or folder.
* Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js
*
* @param source source path
* @param dest destination path
* @param options optional. See CopyOptions.
*/
function cp(source, dest, options = {}) {
return __awaiter(this, void 0, void 0, function* () {
const { force, recursive } = readCopyOptions(options);
const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null;
// Dest is an existing file, but not forcing
if (destStat && destStat.isFile() && !force) {
return;
}
// If dest is an existing directory, should copy inside.
const newDest = destStat && destStat.isDirectory()
? path.join(dest, path.basename(source))
: dest;
if (!(yield ioUtil.exists(source))) {
throw new Error(`no such file or directory: ${source}`);
}
const sourceStat = yield ioUtil.stat(source);
if (sourceStat.isDirectory()) {
if (!recursive) {
throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`);
}
else {
yield cpDirRecursive(source, newDest, 0, force);
}
}
else {
if (path.relative(source, newDest) === '') {
// a file cannot be copied to itself
throw new Error(`'${newDest}' and '${source}' are the same file`);
}
yield copyFile(source, newDest, force);
}
});
}
exports.cp = cp;
/**
* Moves a path.
*
* @param source source path
* @param dest destination path
* @param options optional. See MoveOptions.
*/
function mv(source, dest, options = {}) {
return __awaiter(this, void 0, void 0, function* () {
if (yield ioUtil.exists(dest)) {
let destExists = true;
if (yield ioUtil.isDirectory(dest)) {
// If dest is directory copy src into dest
dest = path.join(dest, path.basename(source));
destExists = yield ioUtil.exists(dest);
}
if (destExists) {
if (options.force == null || options.force) {
yield rmRF(dest);
}
else {
throw new Error('Destination already exists');
}
}
}
yield mkdirP(path.dirname(dest));
yield ioUtil.rename(source, dest);
});
}
exports.mv = mv;
/**
* Remove a path recursively with force
*
* @param inputPath path to remove
*/
function rmRF(inputPath) {
return __awaiter(this, void 0, void 0, function* () {
if (ioUtil.IS_WINDOWS) {
// Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another
// program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del.
try {
if (yield ioUtil.isDirectory(inputPath, true)) {
yield exec(`rd /s /q "${inputPath}"`);
}
else {
yield exec(`del /f /a "${inputPath}"`);
}
}
catch (err) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if (err.code !== 'ENOENT')
throw err;
}
// Shelling out fails to remove a symlink folder with missing source, this unlink catches that
try {
yield ioUtil.unlink(inputPath);
}
catch (err) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if (err.code !== 'ENOENT')
throw err;
}
}
else {
let isDir = false;
try {
isDir = yield ioUtil.isDirectory(inputPath);
}
catch (err) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if (err.code !== 'ENOENT')
throw err;
return;
}
if (isDir) {
yield exec(`rm -rf "${inputPath}"`);
}
else {
yield ioUtil.unlink(inputPath);
}
}
});
}
exports.rmRF = rmRF;
/**
* Make a directory. Creates the full path with folders in between
* Will throw if it fails
*
* @param fsPath path to create
* @returns Promise
*/
function mkdirP(fsPath) {
return __awaiter(this, void 0, void 0, function* () {
yield ioUtil.mkdirP(fsPath);
});
}
exports.mkdirP = mkdirP;
/**
* Returns path of a tool had the tool actually been invoked. Resolves via paths.
* If you check and the tool does not exist, it will throw.
*
* @param tool name of the tool
* @param check whether to check if tool exists
* @returns Promise path to tool
*/
function which(tool, check) {
return __awaiter(this, void 0, void 0, function* () {
if (!tool) {
throw new Error("parameter 'tool' is required");
}
// recursive when check=true
if (check) {
const result = yield which(tool, false);
if (!result) {
if (ioUtil.IS_WINDOWS) {
throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`);
}
else {
throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`);
}
}
return result;
}
const matches = yield findInPath(tool);
if (matches && matches.length > 0) {
return matches[0];
}
return '';
});
}
exports.which = which;
/**
* Returns a list of all occurrences of the given tool on the system path.
*
* @returns Promise the paths of the tool
*/
function findInPath(tool) {
return __awaiter(this, void 0, void 0, function* () {
if (!tool) {
throw new Error("parameter 'tool' is required");
}
// build the list of extensions to try
const extensions = [];
if (ioUtil.IS_WINDOWS && process.env['PATHEXT']) {
for (const extension of process.env['PATHEXT'].split(path.delimiter)) {
if (extension) {
extensions.push(extension);
}
}
}
// if it's rooted, return it if exists. otherwise return empty.
if (ioUtil.isRooted(tool)) {
const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions);
if (filePath) {
return [filePath];
}
return [];
}
// if any path separators, return empty
if (tool.includes(path.sep)) {
return [];
}
// build the list of directories
//
// Note, technically "where" checks the current directory on Windows. From a toolkit perspective,
// it feels like we should not do this. Checking the current directory seems like more of a use
// case of a shell, and the which() function exposed by the toolkit should strive for consistency
// across platforms.
const directories = [];
if (process.env.PATH) {
for (const p of process.env.PATH.split(path.delimiter)) {
if (p) {
directories.push(p);
}
}
}
// find all matches
const matches = [];
for (const directory of directories) {
const filePath = yield ioUtil.tryGetExecutablePath(path.join(directory, tool), extensions);
if (filePath) {
matches.push(filePath);
}
}
return matches;
});
}
exports.findInPath = findInPath;
function readCopyOptions(options) {
const force = options.force == null ? true : options.force;
const recursive = Boolean(options.recursive);
return { force, recursive };
}
function cpDirRecursive(sourceDir, destDir, currentDepth, force) {
return __awaiter(this, void 0, void 0, function* () {
// Ensure there is not a run away recursive copy
if (currentDepth >= 255)
return;
currentDepth++;
yield mkdirP(destDir);
const files = yield ioUtil.readdir(sourceDir);
for (const fileName of files) {
const srcFile = `${sourceDir}/${fileName}`;
const destFile = `${destDir}/${fileName}`;
const srcFileStat = yield ioUtil.lstat(srcFile);
if (srcFileStat.isDirectory()) {
// Recurse
yield cpDirRecursive(srcFile, destFile, currentDepth, force);
}
else {
yield copyFile(srcFile, destFile, force);
}
}
// Change the mode for the newly created directory
yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode);
});
}
// Buffered file copy
function copyFile(srcFile, destFile, force) {
return __awaiter(this, void 0, void 0, function* () {
if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) {
// unlink/re-link it
try {
yield ioUtil.lstat(destFile);
yield ioUtil.unlink(destFile);
}
catch (e) {
// Try to override file permission
if (e.code === 'EPERM') {
yield ioUtil.chmod(destFile, '0666');
yield ioUtil.unlink(destFile);
}
// other errors = it doesn't exist, no work to do
}
// Copy over symlink
const symlinkFull = yield ioUtil.readlink(srcFile);
yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null);
}
else if (!(yield ioUtil.exists(destFile)) || force) {
yield ioUtil.copyFile(srcFile, destFile);
}
});
}
//# sourceMappingURL=io.js.map
/***/ }),
/***/ 56664:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
/**
* Kubernetes
* No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
*
* OpenAPI spec version: v1.13.7
*
*
* NOTE: This class is auto generated by the swagger code generator program.
* https://github.com/swagger-api/swagger-codegen.git
* Do not edit the class manually.
*/
Object.defineProperty(exports, "__esModule", ({ value: true }));
const localVarRequest = __webpack_require__(48699);
let defaultBasePath = 'https://localhost';
// ===============================================
// This file is autogenerated - Please do not edit
// ===============================================
/* tslint:disable:no-unused-variable */
let primitives = [
"string",
"boolean",
"double",
"integer",
"long",
"float",
"number",
"any"
];
class ObjectSerializer {
static findCorrectType(data, expectedType) {
if (data == undefined) {
return expectedType;
}
else if (primitives.indexOf(expectedType.toLowerCase()) !== -1) {
return expectedType;
}
else if (expectedType === "Date") {
return expectedType;
}
else {
if (enumsMap[expectedType]) {
return expectedType;
}
if (!typeMap[expectedType]) {
return expectedType; // w/e we don't know the type
}
// Check the discriminator
let discriminatorProperty = typeMap[expectedType].discriminator;
if (discriminatorProperty == null) {
return expectedType; // the type does not have a discriminator. use it.
}
else {
if (data[discriminatorProperty]) {
return data[discriminatorProperty]; // use the type given in the discriminator
}
else {
return expectedType; // discriminator was not present (or an empty string)
}
}
}
}
static serialize(data, type) {
if (data == undefined) {
return data;
}
else if (primitives.indexOf(type.toLowerCase()) !== -1) {
return data;
}
else if (type.lastIndexOf("Array<", 0) === 0) { // string.startsWith pre es6
let subType = type.replace("Array<", ""); // Array => Type>
subType = subType.substring(0, subType.length - 1); // Type> => Type
let transformedData = [];
for (let index in data) {
let date = data[index];
transformedData.push(ObjectSerializer.serialize(date, subType));
}
return transformedData;
}
else if (type === "Date") {
return data.toString();
}
else {
if (enumsMap[type]) {
return data;
}
if (!typeMap[type]) { // in case we dont know the type
return data;
}
// get the map for the correct type.
let attributeTypes = typeMap[type].getAttributeTypeMap();
let instance = {};
for (let index in attributeTypes) {
let attributeType = attributeTypes[index];
instance[attributeType.baseName] = ObjectSerializer.serialize(data[attributeType.name], attributeType.type);
}
return instance;
}
}
static deserialize(data, type) {
// polymorphism may change the actual type.
type = ObjectSerializer.findCorrectType(data, type);
if (data == undefined) {
return data;
}
else if (primitives.indexOf(type.toLowerCase()) !== -1) {
return data;
}
else if (type.lastIndexOf("Array<", 0) === 0) { // string.startsWith pre es6
let subType = type.replace("Array<", ""); // Array => Type>
subType = subType.substring(0, subType.length - 1); // Type> => Type
let transformedData = [];
for (let index in data) {
let date = data[index];
transformedData.push(ObjectSerializer.deserialize(date, subType));
}
return transformedData;
}
else if (type === "Date") {
return new Date(data);
}
else {
if (enumsMap[type]) { // is Enum
return data;
}
if (!typeMap[type]) { // dont know the type
return data;
}
let instance = new typeMap[type]();
let attributeTypes = typeMap[type].getAttributeTypeMap();
for (let index in attributeTypes) {
let attributeType = attributeTypes[index];
instance[attributeType.name] = ObjectSerializer.deserialize(data[attributeType.baseName], attributeType.type);
}
return instance;
}
}
}
/**
* ServiceReference holds a reference to Service.legacy.k8s.io
*/
class AdmissionregistrationV1beta1ServiceReference {
static getAttributeTypeMap() {
return AdmissionregistrationV1beta1ServiceReference.attributeTypeMap;
}
}
AdmissionregistrationV1beta1ServiceReference.discriminator = undefined;
AdmissionregistrationV1beta1ServiceReference.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
},
{
"name": "path",
"baseName": "path",
"type": "string"
}
];
exports.AdmissionregistrationV1beta1ServiceReference = AdmissionregistrationV1beta1ServiceReference;
/**
* WebhookClientConfig contains the information to make a TLS connection with the webhook
*/
class AdmissionregistrationV1beta1WebhookClientConfig {
static getAttributeTypeMap() {
return AdmissionregistrationV1beta1WebhookClientConfig.attributeTypeMap;
}
}
AdmissionregistrationV1beta1WebhookClientConfig.discriminator = undefined;
AdmissionregistrationV1beta1WebhookClientConfig.attributeTypeMap = [
{
"name": "caBundle",
"baseName": "caBundle",
"type": "string"
},
{
"name": "service",
"baseName": "service",
"type": "AdmissionregistrationV1beta1ServiceReference"
},
{
"name": "url",
"baseName": "url",
"type": "string"
}
];
exports.AdmissionregistrationV1beta1WebhookClientConfig = AdmissionregistrationV1beta1WebhookClientConfig;
/**
* ServiceReference holds a reference to Service.legacy.k8s.io
*/
class ApiextensionsV1beta1ServiceReference {
static getAttributeTypeMap() {
return ApiextensionsV1beta1ServiceReference.attributeTypeMap;
}
}
ApiextensionsV1beta1ServiceReference.discriminator = undefined;
ApiextensionsV1beta1ServiceReference.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
},
{
"name": "path",
"baseName": "path",
"type": "string"
}
];
exports.ApiextensionsV1beta1ServiceReference = ApiextensionsV1beta1ServiceReference;
/**
* WebhookClientConfig contains the information to make a TLS connection with the webhook. It has the same field as admissionregistration.v1beta1.WebhookClientConfig.
*/
class ApiextensionsV1beta1WebhookClientConfig {
static getAttributeTypeMap() {
return ApiextensionsV1beta1WebhookClientConfig.attributeTypeMap;
}
}
ApiextensionsV1beta1WebhookClientConfig.discriminator = undefined;
ApiextensionsV1beta1WebhookClientConfig.attributeTypeMap = [
{
"name": "caBundle",
"baseName": "caBundle",
"type": "string"
},
{
"name": "service",
"baseName": "service",
"type": "ApiextensionsV1beta1ServiceReference"
},
{
"name": "url",
"baseName": "url",
"type": "string"
}
];
exports.ApiextensionsV1beta1WebhookClientConfig = ApiextensionsV1beta1WebhookClientConfig;
/**
* ServiceReference holds a reference to Service.legacy.k8s.io
*/
class ApiregistrationV1beta1ServiceReference {
static getAttributeTypeMap() {
return ApiregistrationV1beta1ServiceReference.attributeTypeMap;
}
}
ApiregistrationV1beta1ServiceReference.discriminator = undefined;
ApiregistrationV1beta1ServiceReference.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
}
];
exports.ApiregistrationV1beta1ServiceReference = ApiregistrationV1beta1ServiceReference;
/**
* 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.
*/
class AppsV1beta1Deployment {
static getAttributeTypeMap() {
return AppsV1beta1Deployment.attributeTypeMap;
}
}
AppsV1beta1Deployment.discriminator = undefined;
AppsV1beta1Deployment.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "AppsV1beta1DeploymentSpec"
},
{
"name": "status",
"baseName": "status",
"type": "AppsV1beta1DeploymentStatus"
}
];
exports.AppsV1beta1Deployment = AppsV1beta1Deployment;
/**
* DeploymentCondition describes the state of a deployment at a certain point.
*/
class AppsV1beta1DeploymentCondition {
static getAttributeTypeMap() {
return AppsV1beta1DeploymentCondition.attributeTypeMap;
}
}
AppsV1beta1DeploymentCondition.discriminator = undefined;
AppsV1beta1DeploymentCondition.attributeTypeMap = [
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "lastUpdateTime",
"baseName": "lastUpdateTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.AppsV1beta1DeploymentCondition = AppsV1beta1DeploymentCondition;
/**
* DeploymentList is a list of Deployments.
*/
class AppsV1beta1DeploymentList {
static getAttributeTypeMap() {
return AppsV1beta1DeploymentList.attributeTypeMap;
}
}
AppsV1beta1DeploymentList.discriminator = undefined;
AppsV1beta1DeploymentList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.AppsV1beta1DeploymentList = AppsV1beta1DeploymentList;
/**
* DEPRECATED. DeploymentRollback stores the information required to rollback a deployment.
*/
class AppsV1beta1DeploymentRollback {
static getAttributeTypeMap() {
return AppsV1beta1DeploymentRollback.attributeTypeMap;
}
}
AppsV1beta1DeploymentRollback.discriminator = undefined;
AppsV1beta1DeploymentRollback.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "rollbackTo",
"baseName": "rollbackTo",
"type": "AppsV1beta1RollbackConfig"
},
{
"name": "updatedAnnotations",
"baseName": "updatedAnnotations",
"type": "{ [key: string]: string; }"
}
];
exports.AppsV1beta1DeploymentRollback = AppsV1beta1DeploymentRollback;
/**
* DeploymentSpec is the specification of the desired behavior of the Deployment.
*/
class AppsV1beta1DeploymentSpec {
static getAttributeTypeMap() {
return AppsV1beta1DeploymentSpec.attributeTypeMap;
}
}
AppsV1beta1DeploymentSpec.discriminator = undefined;
AppsV1beta1DeploymentSpec.attributeTypeMap = [
{
"name": "minReadySeconds",
"baseName": "minReadySeconds",
"type": "number"
},
{
"name": "paused",
"baseName": "paused",
"type": "boolean"
},
{
"name": "progressDeadlineSeconds",
"baseName": "progressDeadlineSeconds",
"type": "number"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "revisionHistoryLimit",
"baseName": "revisionHistoryLimit",
"type": "number"
},
{
"name": "rollbackTo",
"baseName": "rollbackTo",
"type": "AppsV1beta1RollbackConfig"
},
{
"name": "selector",
"baseName": "selector",
"type": "V1LabelSelector"
},
{
"name": "strategy",
"baseName": "strategy",
"type": "AppsV1beta1DeploymentStrategy"
},
{
"name": "template",
"baseName": "template",
"type": "V1PodTemplateSpec"
}
];
exports.AppsV1beta1DeploymentSpec = AppsV1beta1DeploymentSpec;
/**
* DeploymentStatus is the most recently observed status of the Deployment.
*/
class AppsV1beta1DeploymentStatus {
static getAttributeTypeMap() {
return AppsV1beta1DeploymentStatus.attributeTypeMap;
}
}
AppsV1beta1DeploymentStatus.discriminator = undefined;
AppsV1beta1DeploymentStatus.attributeTypeMap = [
{
"name": "availableReplicas",
"baseName": "availableReplicas",
"type": "number"
},
{
"name": "collisionCount",
"baseName": "collisionCount",
"type": "number"
},
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "observedGeneration",
"baseName": "observedGeneration",
"type": "number"
},
{
"name": "readyReplicas",
"baseName": "readyReplicas",
"type": "number"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "unavailableReplicas",
"baseName": "unavailableReplicas",
"type": "number"
},
{
"name": "updatedReplicas",
"baseName": "updatedReplicas",
"type": "number"
}
];
exports.AppsV1beta1DeploymentStatus = AppsV1beta1DeploymentStatus;
/**
* DeploymentStrategy describes how to replace existing pods with new ones.
*/
class AppsV1beta1DeploymentStrategy {
static getAttributeTypeMap() {
return AppsV1beta1DeploymentStrategy.attributeTypeMap;
}
}
AppsV1beta1DeploymentStrategy.discriminator = undefined;
AppsV1beta1DeploymentStrategy.attributeTypeMap = [
{
"name": "rollingUpdate",
"baseName": "rollingUpdate",
"type": "AppsV1beta1RollingUpdateDeployment"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.AppsV1beta1DeploymentStrategy = AppsV1beta1DeploymentStrategy;
/**
* DEPRECATED.
*/
class AppsV1beta1RollbackConfig {
static getAttributeTypeMap() {
return AppsV1beta1RollbackConfig.attributeTypeMap;
}
}
AppsV1beta1RollbackConfig.discriminator = undefined;
AppsV1beta1RollbackConfig.attributeTypeMap = [
{
"name": "revision",
"baseName": "revision",
"type": "number"
}
];
exports.AppsV1beta1RollbackConfig = AppsV1beta1RollbackConfig;
/**
* Spec to control the desired behavior of rolling update.
*/
class AppsV1beta1RollingUpdateDeployment {
static getAttributeTypeMap() {
return AppsV1beta1RollingUpdateDeployment.attributeTypeMap;
}
}
AppsV1beta1RollingUpdateDeployment.discriminator = undefined;
AppsV1beta1RollingUpdateDeployment.attributeTypeMap = [
{
"name": "maxSurge",
"baseName": "maxSurge",
"type": "any"
},
{
"name": "maxUnavailable",
"baseName": "maxUnavailable",
"type": "any"
}
];
exports.AppsV1beta1RollingUpdateDeployment = AppsV1beta1RollingUpdateDeployment;
/**
* Scale represents a scaling request for a resource.
*/
class AppsV1beta1Scale {
static getAttributeTypeMap() {
return AppsV1beta1Scale.attributeTypeMap;
}
}
AppsV1beta1Scale.discriminator = undefined;
AppsV1beta1Scale.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "AppsV1beta1ScaleSpec"
},
{
"name": "status",
"baseName": "status",
"type": "AppsV1beta1ScaleStatus"
}
];
exports.AppsV1beta1Scale = AppsV1beta1Scale;
/**
* ScaleSpec describes the attributes of a scale subresource
*/
class AppsV1beta1ScaleSpec {
static getAttributeTypeMap() {
return AppsV1beta1ScaleSpec.attributeTypeMap;
}
}
AppsV1beta1ScaleSpec.discriminator = undefined;
AppsV1beta1ScaleSpec.attributeTypeMap = [
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
}
];
exports.AppsV1beta1ScaleSpec = AppsV1beta1ScaleSpec;
/**
* ScaleStatus represents the current status of a scale subresource.
*/
class AppsV1beta1ScaleStatus {
static getAttributeTypeMap() {
return AppsV1beta1ScaleStatus.attributeTypeMap;
}
}
AppsV1beta1ScaleStatus.discriminator = undefined;
AppsV1beta1ScaleStatus.attributeTypeMap = [
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "selector",
"baseName": "selector",
"type": "{ [key: string]: string; }"
},
{
"name": "targetSelector",
"baseName": "targetSelector",
"type": "string"
}
];
exports.AppsV1beta1ScaleStatus = AppsV1beta1ScaleStatus;
/**
* AllowedFlexVolume represents a single Flexvolume that is allowed to be used. Deprecated: use AllowedFlexVolume from policy API Group instead.
*/
class ExtensionsV1beta1AllowedFlexVolume {
static getAttributeTypeMap() {
return ExtensionsV1beta1AllowedFlexVolume.attributeTypeMap;
}
}
ExtensionsV1beta1AllowedFlexVolume.discriminator = undefined;
ExtensionsV1beta1AllowedFlexVolume.attributeTypeMap = [
{
"name": "driver",
"baseName": "driver",
"type": "string"
}
];
exports.ExtensionsV1beta1AllowedFlexVolume = ExtensionsV1beta1AllowedFlexVolume;
/**
* 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.
*/
class ExtensionsV1beta1AllowedHostPath {
static getAttributeTypeMap() {
return ExtensionsV1beta1AllowedHostPath.attributeTypeMap;
}
}
ExtensionsV1beta1AllowedHostPath.discriminator = undefined;
ExtensionsV1beta1AllowedHostPath.attributeTypeMap = [
{
"name": "pathPrefix",
"baseName": "pathPrefix",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
}
];
exports.ExtensionsV1beta1AllowedHostPath = ExtensionsV1beta1AllowedHostPath;
/**
* 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.
*/
class ExtensionsV1beta1Deployment {
static getAttributeTypeMap() {
return ExtensionsV1beta1Deployment.attributeTypeMap;
}
}
ExtensionsV1beta1Deployment.discriminator = undefined;
ExtensionsV1beta1Deployment.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "ExtensionsV1beta1DeploymentSpec"
},
{
"name": "status",
"baseName": "status",
"type": "ExtensionsV1beta1DeploymentStatus"
}
];
exports.ExtensionsV1beta1Deployment = ExtensionsV1beta1Deployment;
/**
* DeploymentCondition describes the state of a deployment at a certain point.
*/
class ExtensionsV1beta1DeploymentCondition {
static getAttributeTypeMap() {
return ExtensionsV1beta1DeploymentCondition.attributeTypeMap;
}
}
ExtensionsV1beta1DeploymentCondition.discriminator = undefined;
ExtensionsV1beta1DeploymentCondition.attributeTypeMap = [
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "lastUpdateTime",
"baseName": "lastUpdateTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.ExtensionsV1beta1DeploymentCondition = ExtensionsV1beta1DeploymentCondition;
/**
* DeploymentList is a list of Deployments.
*/
class ExtensionsV1beta1DeploymentList {
static getAttributeTypeMap() {
return ExtensionsV1beta1DeploymentList.attributeTypeMap;
}
}
ExtensionsV1beta1DeploymentList.discriminator = undefined;
ExtensionsV1beta1DeploymentList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.ExtensionsV1beta1DeploymentList = ExtensionsV1beta1DeploymentList;
/**
* DEPRECATED. DeploymentRollback stores the information required to rollback a deployment.
*/
class ExtensionsV1beta1DeploymentRollback {
static getAttributeTypeMap() {
return ExtensionsV1beta1DeploymentRollback.attributeTypeMap;
}
}
ExtensionsV1beta1DeploymentRollback.discriminator = undefined;
ExtensionsV1beta1DeploymentRollback.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "rollbackTo",
"baseName": "rollbackTo",
"type": "ExtensionsV1beta1RollbackConfig"
},
{
"name": "updatedAnnotations",
"baseName": "updatedAnnotations",
"type": "{ [key: string]: string; }"
}
];
exports.ExtensionsV1beta1DeploymentRollback = ExtensionsV1beta1DeploymentRollback;
/**
* DeploymentSpec is the specification of the desired behavior of the Deployment.
*/
class ExtensionsV1beta1DeploymentSpec {
static getAttributeTypeMap() {
return ExtensionsV1beta1DeploymentSpec.attributeTypeMap;
}
}
ExtensionsV1beta1DeploymentSpec.discriminator = undefined;
ExtensionsV1beta1DeploymentSpec.attributeTypeMap = [
{
"name": "minReadySeconds",
"baseName": "minReadySeconds",
"type": "number"
},
{
"name": "paused",
"baseName": "paused",
"type": "boolean"
},
{
"name": "progressDeadlineSeconds",
"baseName": "progressDeadlineSeconds",
"type": "number"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "revisionHistoryLimit",
"baseName": "revisionHistoryLimit",
"type": "number"
},
{
"name": "rollbackTo",
"baseName": "rollbackTo",
"type": "ExtensionsV1beta1RollbackConfig"
},
{
"name": "selector",
"baseName": "selector",
"type": "V1LabelSelector"
},
{
"name": "strategy",
"baseName": "strategy",
"type": "ExtensionsV1beta1DeploymentStrategy"
},
{
"name": "template",
"baseName": "template",
"type": "V1PodTemplateSpec"
}
];
exports.ExtensionsV1beta1DeploymentSpec = ExtensionsV1beta1DeploymentSpec;
/**
* DeploymentStatus is the most recently observed status of the Deployment.
*/
class ExtensionsV1beta1DeploymentStatus {
static getAttributeTypeMap() {
return ExtensionsV1beta1DeploymentStatus.attributeTypeMap;
}
}
ExtensionsV1beta1DeploymentStatus.discriminator = undefined;
ExtensionsV1beta1DeploymentStatus.attributeTypeMap = [
{
"name": "availableReplicas",
"baseName": "availableReplicas",
"type": "number"
},
{
"name": "collisionCount",
"baseName": "collisionCount",
"type": "number"
},
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "observedGeneration",
"baseName": "observedGeneration",
"type": "number"
},
{
"name": "readyReplicas",
"baseName": "readyReplicas",
"type": "number"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "unavailableReplicas",
"baseName": "unavailableReplicas",
"type": "number"
},
{
"name": "updatedReplicas",
"baseName": "updatedReplicas",
"type": "number"
}
];
exports.ExtensionsV1beta1DeploymentStatus = ExtensionsV1beta1DeploymentStatus;
/**
* DeploymentStrategy describes how to replace existing pods with new ones.
*/
class ExtensionsV1beta1DeploymentStrategy {
static getAttributeTypeMap() {
return ExtensionsV1beta1DeploymentStrategy.attributeTypeMap;
}
}
ExtensionsV1beta1DeploymentStrategy.discriminator = undefined;
ExtensionsV1beta1DeploymentStrategy.attributeTypeMap = [
{
"name": "rollingUpdate",
"baseName": "rollingUpdate",
"type": "ExtensionsV1beta1RollingUpdateDeployment"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.ExtensionsV1beta1DeploymentStrategy = ExtensionsV1beta1DeploymentStrategy;
/**
* FSGroupStrategyOptions defines the strategy type and options used to create the strategy. Deprecated: use FSGroupStrategyOptions from policy API Group instead.
*/
class ExtensionsV1beta1FSGroupStrategyOptions {
static getAttributeTypeMap() {
return ExtensionsV1beta1FSGroupStrategyOptions.attributeTypeMap;
}
}
ExtensionsV1beta1FSGroupStrategyOptions.discriminator = undefined;
ExtensionsV1beta1FSGroupStrategyOptions.attributeTypeMap = [
{
"name": "ranges",
"baseName": "ranges",
"type": "Array"
},
{
"name": "rule",
"baseName": "rule",
"type": "string"
}
];
exports.ExtensionsV1beta1FSGroupStrategyOptions = ExtensionsV1beta1FSGroupStrategyOptions;
/**
* 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.
*/
class ExtensionsV1beta1HostPortRange {
static getAttributeTypeMap() {
return ExtensionsV1beta1HostPortRange.attributeTypeMap;
}
}
ExtensionsV1beta1HostPortRange.discriminator = undefined;
ExtensionsV1beta1HostPortRange.attributeTypeMap = [
{
"name": "max",
"baseName": "max",
"type": "number"
},
{
"name": "min",
"baseName": "min",
"type": "number"
}
];
exports.ExtensionsV1beta1HostPortRange = ExtensionsV1beta1HostPortRange;
/**
* IDRange provides a min/max of an allowed range of IDs. Deprecated: use IDRange from policy API Group instead.
*/
class ExtensionsV1beta1IDRange {
static getAttributeTypeMap() {
return ExtensionsV1beta1IDRange.attributeTypeMap;
}
}
ExtensionsV1beta1IDRange.discriminator = undefined;
ExtensionsV1beta1IDRange.attributeTypeMap = [
{
"name": "max",
"baseName": "max",
"type": "number"
},
{
"name": "min",
"baseName": "min",
"type": "number"
}
];
exports.ExtensionsV1beta1IDRange = ExtensionsV1beta1IDRange;
/**
* 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.
*/
class ExtensionsV1beta1PodSecurityPolicy {
static getAttributeTypeMap() {
return ExtensionsV1beta1PodSecurityPolicy.attributeTypeMap;
}
}
ExtensionsV1beta1PodSecurityPolicy.discriminator = undefined;
ExtensionsV1beta1PodSecurityPolicy.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "ExtensionsV1beta1PodSecurityPolicySpec"
}
];
exports.ExtensionsV1beta1PodSecurityPolicy = ExtensionsV1beta1PodSecurityPolicy;
/**
* PodSecurityPolicyList is a list of PodSecurityPolicy objects. Deprecated: use PodSecurityPolicyList from policy API Group instead.
*/
class ExtensionsV1beta1PodSecurityPolicyList {
static getAttributeTypeMap() {
return ExtensionsV1beta1PodSecurityPolicyList.attributeTypeMap;
}
}
ExtensionsV1beta1PodSecurityPolicyList.discriminator = undefined;
ExtensionsV1beta1PodSecurityPolicyList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.ExtensionsV1beta1PodSecurityPolicyList = ExtensionsV1beta1PodSecurityPolicyList;
/**
* PodSecurityPolicySpec defines the policy enforced. Deprecated: use PodSecurityPolicySpec from policy API Group instead.
*/
class ExtensionsV1beta1PodSecurityPolicySpec {
static getAttributeTypeMap() {
return ExtensionsV1beta1PodSecurityPolicySpec.attributeTypeMap;
}
}
ExtensionsV1beta1PodSecurityPolicySpec.discriminator = undefined;
ExtensionsV1beta1PodSecurityPolicySpec.attributeTypeMap = [
{
"name": "allowPrivilegeEscalation",
"baseName": "allowPrivilegeEscalation",
"type": "boolean"
},
{
"name": "allowedCapabilities",
"baseName": "allowedCapabilities",
"type": "Array"
},
{
"name": "allowedFlexVolumes",
"baseName": "allowedFlexVolumes",
"type": "Array"
},
{
"name": "allowedHostPaths",
"baseName": "allowedHostPaths",
"type": "Array"
},
{
"name": "allowedProcMountTypes",
"baseName": "allowedProcMountTypes",
"type": "Array"
},
{
"name": "allowedUnsafeSysctls",
"baseName": "allowedUnsafeSysctls",
"type": "Array"
},
{
"name": "defaultAddCapabilities",
"baseName": "defaultAddCapabilities",
"type": "Array"
},
{
"name": "defaultAllowPrivilegeEscalation",
"baseName": "defaultAllowPrivilegeEscalation",
"type": "boolean"
},
{
"name": "forbiddenSysctls",
"baseName": "forbiddenSysctls",
"type": "Array"
},
{
"name": "fsGroup",
"baseName": "fsGroup",
"type": "ExtensionsV1beta1FSGroupStrategyOptions"
},
{
"name": "hostIPC",
"baseName": "hostIPC",
"type": "boolean"
},
{
"name": "hostNetwork",
"baseName": "hostNetwork",
"type": "boolean"
},
{
"name": "hostPID",
"baseName": "hostPID",
"type": "boolean"
},
{
"name": "hostPorts",
"baseName": "hostPorts",
"type": "Array"
},
{
"name": "privileged",
"baseName": "privileged",
"type": "boolean"
},
{
"name": "readOnlyRootFilesystem",
"baseName": "readOnlyRootFilesystem",
"type": "boolean"
},
{
"name": "requiredDropCapabilities",
"baseName": "requiredDropCapabilities",
"type": "Array"
},
{
"name": "runAsGroup",
"baseName": "runAsGroup",
"type": "ExtensionsV1beta1RunAsGroupStrategyOptions"
},
{
"name": "runAsUser",
"baseName": "runAsUser",
"type": "ExtensionsV1beta1RunAsUserStrategyOptions"
},
{
"name": "seLinux",
"baseName": "seLinux",
"type": "ExtensionsV1beta1SELinuxStrategyOptions"
},
{
"name": "supplementalGroups",
"baseName": "supplementalGroups",
"type": "ExtensionsV1beta1SupplementalGroupsStrategyOptions"
},
{
"name": "volumes",
"baseName": "volumes",
"type": "Array"
}
];
exports.ExtensionsV1beta1PodSecurityPolicySpec = ExtensionsV1beta1PodSecurityPolicySpec;
/**
* DEPRECATED.
*/
class ExtensionsV1beta1RollbackConfig {
static getAttributeTypeMap() {
return ExtensionsV1beta1RollbackConfig.attributeTypeMap;
}
}
ExtensionsV1beta1RollbackConfig.discriminator = undefined;
ExtensionsV1beta1RollbackConfig.attributeTypeMap = [
{
"name": "revision",
"baseName": "revision",
"type": "number"
}
];
exports.ExtensionsV1beta1RollbackConfig = ExtensionsV1beta1RollbackConfig;
/**
* Spec to control the desired behavior of rolling update.
*/
class ExtensionsV1beta1RollingUpdateDeployment {
static getAttributeTypeMap() {
return ExtensionsV1beta1RollingUpdateDeployment.attributeTypeMap;
}
}
ExtensionsV1beta1RollingUpdateDeployment.discriminator = undefined;
ExtensionsV1beta1RollingUpdateDeployment.attributeTypeMap = [
{
"name": "maxSurge",
"baseName": "maxSurge",
"type": "any"
},
{
"name": "maxUnavailable",
"baseName": "maxUnavailable",
"type": "any"
}
];
exports.ExtensionsV1beta1RollingUpdateDeployment = ExtensionsV1beta1RollingUpdateDeployment;
/**
* RunAsGroupStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use RunAsGroupStrategyOptions from policy API Group instead.
*/
class ExtensionsV1beta1RunAsGroupStrategyOptions {
static getAttributeTypeMap() {
return ExtensionsV1beta1RunAsGroupStrategyOptions.attributeTypeMap;
}
}
ExtensionsV1beta1RunAsGroupStrategyOptions.discriminator = undefined;
ExtensionsV1beta1RunAsGroupStrategyOptions.attributeTypeMap = [
{
"name": "ranges",
"baseName": "ranges",
"type": "Array"
},
{
"name": "rule",
"baseName": "rule",
"type": "string"
}
];
exports.ExtensionsV1beta1RunAsGroupStrategyOptions = ExtensionsV1beta1RunAsGroupStrategyOptions;
/**
* RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use RunAsUserStrategyOptions from policy API Group instead.
*/
class ExtensionsV1beta1RunAsUserStrategyOptions {
static getAttributeTypeMap() {
return ExtensionsV1beta1RunAsUserStrategyOptions.attributeTypeMap;
}
}
ExtensionsV1beta1RunAsUserStrategyOptions.discriminator = undefined;
ExtensionsV1beta1RunAsUserStrategyOptions.attributeTypeMap = [
{
"name": "ranges",
"baseName": "ranges",
"type": "Array"
},
{
"name": "rule",
"baseName": "rule",
"type": "string"
}
];
exports.ExtensionsV1beta1RunAsUserStrategyOptions = ExtensionsV1beta1RunAsUserStrategyOptions;
/**
* SELinuxStrategyOptions defines the strategy type and any options used to create the strategy. Deprecated: use SELinuxStrategyOptions from policy API Group instead.
*/
class ExtensionsV1beta1SELinuxStrategyOptions {
static getAttributeTypeMap() {
return ExtensionsV1beta1SELinuxStrategyOptions.attributeTypeMap;
}
}
ExtensionsV1beta1SELinuxStrategyOptions.discriminator = undefined;
ExtensionsV1beta1SELinuxStrategyOptions.attributeTypeMap = [
{
"name": "rule",
"baseName": "rule",
"type": "string"
},
{
"name": "seLinuxOptions",
"baseName": "seLinuxOptions",
"type": "V1SELinuxOptions"
}
];
exports.ExtensionsV1beta1SELinuxStrategyOptions = ExtensionsV1beta1SELinuxStrategyOptions;
/**
* represents a scaling request for a resource.
*/
class ExtensionsV1beta1Scale {
static getAttributeTypeMap() {
return ExtensionsV1beta1Scale.attributeTypeMap;
}
}
ExtensionsV1beta1Scale.discriminator = undefined;
ExtensionsV1beta1Scale.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "ExtensionsV1beta1ScaleSpec"
},
{
"name": "status",
"baseName": "status",
"type": "ExtensionsV1beta1ScaleStatus"
}
];
exports.ExtensionsV1beta1Scale = ExtensionsV1beta1Scale;
/**
* describes the attributes of a scale subresource
*/
class ExtensionsV1beta1ScaleSpec {
static getAttributeTypeMap() {
return ExtensionsV1beta1ScaleSpec.attributeTypeMap;
}
}
ExtensionsV1beta1ScaleSpec.discriminator = undefined;
ExtensionsV1beta1ScaleSpec.attributeTypeMap = [
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
}
];
exports.ExtensionsV1beta1ScaleSpec = ExtensionsV1beta1ScaleSpec;
/**
* represents the current status of a scale subresource.
*/
class ExtensionsV1beta1ScaleStatus {
static getAttributeTypeMap() {
return ExtensionsV1beta1ScaleStatus.attributeTypeMap;
}
}
ExtensionsV1beta1ScaleStatus.discriminator = undefined;
ExtensionsV1beta1ScaleStatus.attributeTypeMap = [
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "selector",
"baseName": "selector",
"type": "{ [key: string]: string; }"
},
{
"name": "targetSelector",
"baseName": "targetSelector",
"type": "string"
}
];
exports.ExtensionsV1beta1ScaleStatus = ExtensionsV1beta1ScaleStatus;
/**
* SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy. Deprecated: use SupplementalGroupsStrategyOptions from policy API Group instead.
*/
class ExtensionsV1beta1SupplementalGroupsStrategyOptions {
static getAttributeTypeMap() {
return ExtensionsV1beta1SupplementalGroupsStrategyOptions.attributeTypeMap;
}
}
ExtensionsV1beta1SupplementalGroupsStrategyOptions.discriminator = undefined;
ExtensionsV1beta1SupplementalGroupsStrategyOptions.attributeTypeMap = [
{
"name": "ranges",
"baseName": "ranges",
"type": "Array"
},
{
"name": "rule",
"baseName": "rule",
"type": "string"
}
];
exports.ExtensionsV1beta1SupplementalGroupsStrategyOptions = ExtensionsV1beta1SupplementalGroupsStrategyOptions;
/**
* AllowedFlexVolume represents a single Flexvolume that is allowed to be used.
*/
class PolicyV1beta1AllowedFlexVolume {
static getAttributeTypeMap() {
return PolicyV1beta1AllowedFlexVolume.attributeTypeMap;
}
}
PolicyV1beta1AllowedFlexVolume.discriminator = undefined;
PolicyV1beta1AllowedFlexVolume.attributeTypeMap = [
{
"name": "driver",
"baseName": "driver",
"type": "string"
}
];
exports.PolicyV1beta1AllowedFlexVolume = PolicyV1beta1AllowedFlexVolume;
/**
* 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.
*/
class PolicyV1beta1AllowedHostPath {
static getAttributeTypeMap() {
return PolicyV1beta1AllowedHostPath.attributeTypeMap;
}
}
PolicyV1beta1AllowedHostPath.discriminator = undefined;
PolicyV1beta1AllowedHostPath.attributeTypeMap = [
{
"name": "pathPrefix",
"baseName": "pathPrefix",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
}
];
exports.PolicyV1beta1AllowedHostPath = PolicyV1beta1AllowedHostPath;
/**
* FSGroupStrategyOptions defines the strategy type and options used to create the strategy.
*/
class PolicyV1beta1FSGroupStrategyOptions {
static getAttributeTypeMap() {
return PolicyV1beta1FSGroupStrategyOptions.attributeTypeMap;
}
}
PolicyV1beta1FSGroupStrategyOptions.discriminator = undefined;
PolicyV1beta1FSGroupStrategyOptions.attributeTypeMap = [
{
"name": "ranges",
"baseName": "ranges",
"type": "Array"
},
{
"name": "rule",
"baseName": "rule",
"type": "string"
}
];
exports.PolicyV1beta1FSGroupStrategyOptions = PolicyV1beta1FSGroupStrategyOptions;
/**
* 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.
*/
class PolicyV1beta1HostPortRange {
static getAttributeTypeMap() {
return PolicyV1beta1HostPortRange.attributeTypeMap;
}
}
PolicyV1beta1HostPortRange.discriminator = undefined;
PolicyV1beta1HostPortRange.attributeTypeMap = [
{
"name": "max",
"baseName": "max",
"type": "number"
},
{
"name": "min",
"baseName": "min",
"type": "number"
}
];
exports.PolicyV1beta1HostPortRange = PolicyV1beta1HostPortRange;
/**
* IDRange provides a min/max of an allowed range of IDs.
*/
class PolicyV1beta1IDRange {
static getAttributeTypeMap() {
return PolicyV1beta1IDRange.attributeTypeMap;
}
}
PolicyV1beta1IDRange.discriminator = undefined;
PolicyV1beta1IDRange.attributeTypeMap = [
{
"name": "max",
"baseName": "max",
"type": "number"
},
{
"name": "min",
"baseName": "min",
"type": "number"
}
];
exports.PolicyV1beta1IDRange = PolicyV1beta1IDRange;
/**
* PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container.
*/
class PolicyV1beta1PodSecurityPolicy {
static getAttributeTypeMap() {
return PolicyV1beta1PodSecurityPolicy.attributeTypeMap;
}
}
PolicyV1beta1PodSecurityPolicy.discriminator = undefined;
PolicyV1beta1PodSecurityPolicy.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "PolicyV1beta1PodSecurityPolicySpec"
}
];
exports.PolicyV1beta1PodSecurityPolicy = PolicyV1beta1PodSecurityPolicy;
/**
* PodSecurityPolicyList is a list of PodSecurityPolicy objects.
*/
class PolicyV1beta1PodSecurityPolicyList {
static getAttributeTypeMap() {
return PolicyV1beta1PodSecurityPolicyList.attributeTypeMap;
}
}
PolicyV1beta1PodSecurityPolicyList.discriminator = undefined;
PolicyV1beta1PodSecurityPolicyList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.PolicyV1beta1PodSecurityPolicyList = PolicyV1beta1PodSecurityPolicyList;
/**
* PodSecurityPolicySpec defines the policy enforced.
*/
class PolicyV1beta1PodSecurityPolicySpec {
static getAttributeTypeMap() {
return PolicyV1beta1PodSecurityPolicySpec.attributeTypeMap;
}
}
PolicyV1beta1PodSecurityPolicySpec.discriminator = undefined;
PolicyV1beta1PodSecurityPolicySpec.attributeTypeMap = [
{
"name": "allowPrivilegeEscalation",
"baseName": "allowPrivilegeEscalation",
"type": "boolean"
},
{
"name": "allowedCapabilities",
"baseName": "allowedCapabilities",
"type": "Array"
},
{
"name": "allowedFlexVolumes",
"baseName": "allowedFlexVolumes",
"type": "Array"
},
{
"name": "allowedHostPaths",
"baseName": "allowedHostPaths",
"type": "Array"
},
{
"name": "allowedProcMountTypes",
"baseName": "allowedProcMountTypes",
"type": "Array"
},
{
"name": "allowedUnsafeSysctls",
"baseName": "allowedUnsafeSysctls",
"type": "Array"
},
{
"name": "defaultAddCapabilities",
"baseName": "defaultAddCapabilities",
"type": "Array"
},
{
"name": "defaultAllowPrivilegeEscalation",
"baseName": "defaultAllowPrivilegeEscalation",
"type": "boolean"
},
{
"name": "forbiddenSysctls",
"baseName": "forbiddenSysctls",
"type": "Array"
},
{
"name": "fsGroup",
"baseName": "fsGroup",
"type": "PolicyV1beta1FSGroupStrategyOptions"
},
{
"name": "hostIPC",
"baseName": "hostIPC",
"type": "boolean"
},
{
"name": "hostNetwork",
"baseName": "hostNetwork",
"type": "boolean"
},
{
"name": "hostPID",
"baseName": "hostPID",
"type": "boolean"
},
{
"name": "hostPorts",
"baseName": "hostPorts",
"type": "Array"
},
{
"name": "privileged",
"baseName": "privileged",
"type": "boolean"
},
{
"name": "readOnlyRootFilesystem",
"baseName": "readOnlyRootFilesystem",
"type": "boolean"
},
{
"name": "requiredDropCapabilities",
"baseName": "requiredDropCapabilities",
"type": "Array"
},
{
"name": "runAsGroup",
"baseName": "runAsGroup",
"type": "PolicyV1beta1RunAsGroupStrategyOptions"
},
{
"name": "runAsUser",
"baseName": "runAsUser",
"type": "PolicyV1beta1RunAsUserStrategyOptions"
},
{
"name": "seLinux",
"baseName": "seLinux",
"type": "PolicyV1beta1SELinuxStrategyOptions"
},
{
"name": "supplementalGroups",
"baseName": "supplementalGroups",
"type": "PolicyV1beta1SupplementalGroupsStrategyOptions"
},
{
"name": "volumes",
"baseName": "volumes",
"type": "Array"
}
];
exports.PolicyV1beta1PodSecurityPolicySpec = PolicyV1beta1PodSecurityPolicySpec;
/**
* RunAsGroupStrategyOptions defines the strategy type and any options used to create the strategy.
*/
class PolicyV1beta1RunAsGroupStrategyOptions {
static getAttributeTypeMap() {
return PolicyV1beta1RunAsGroupStrategyOptions.attributeTypeMap;
}
}
PolicyV1beta1RunAsGroupStrategyOptions.discriminator = undefined;
PolicyV1beta1RunAsGroupStrategyOptions.attributeTypeMap = [
{
"name": "ranges",
"baseName": "ranges",
"type": "Array"
},
{
"name": "rule",
"baseName": "rule",
"type": "string"
}
];
exports.PolicyV1beta1RunAsGroupStrategyOptions = PolicyV1beta1RunAsGroupStrategyOptions;
/**
* RunAsUserStrategyOptions defines the strategy type and any options used to create the strategy.
*/
class PolicyV1beta1RunAsUserStrategyOptions {
static getAttributeTypeMap() {
return PolicyV1beta1RunAsUserStrategyOptions.attributeTypeMap;
}
}
PolicyV1beta1RunAsUserStrategyOptions.discriminator = undefined;
PolicyV1beta1RunAsUserStrategyOptions.attributeTypeMap = [
{
"name": "ranges",
"baseName": "ranges",
"type": "Array"
},
{
"name": "rule",
"baseName": "rule",
"type": "string"
}
];
exports.PolicyV1beta1RunAsUserStrategyOptions = PolicyV1beta1RunAsUserStrategyOptions;
/**
* SELinuxStrategyOptions defines the strategy type and any options used to create the strategy.
*/
class PolicyV1beta1SELinuxStrategyOptions {
static getAttributeTypeMap() {
return PolicyV1beta1SELinuxStrategyOptions.attributeTypeMap;
}
}
PolicyV1beta1SELinuxStrategyOptions.discriminator = undefined;
PolicyV1beta1SELinuxStrategyOptions.attributeTypeMap = [
{
"name": "rule",
"baseName": "rule",
"type": "string"
},
{
"name": "seLinuxOptions",
"baseName": "seLinuxOptions",
"type": "V1SELinuxOptions"
}
];
exports.PolicyV1beta1SELinuxStrategyOptions = PolicyV1beta1SELinuxStrategyOptions;
/**
* SupplementalGroupsStrategyOptions defines the strategy type and options used to create the strategy.
*/
class PolicyV1beta1SupplementalGroupsStrategyOptions {
static getAttributeTypeMap() {
return PolicyV1beta1SupplementalGroupsStrategyOptions.attributeTypeMap;
}
}
PolicyV1beta1SupplementalGroupsStrategyOptions.discriminator = undefined;
PolicyV1beta1SupplementalGroupsStrategyOptions.attributeTypeMap = [
{
"name": "ranges",
"baseName": "ranges",
"type": "Array"
},
{
"name": "rule",
"baseName": "rule",
"type": "string"
}
];
exports.PolicyV1beta1SupplementalGroupsStrategyOptions = PolicyV1beta1SupplementalGroupsStrategyOptions;
/**
* 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.)
*/
class RuntimeRawExtension {
static getAttributeTypeMap() {
return RuntimeRawExtension.attributeTypeMap;
}
}
RuntimeRawExtension.discriminator = undefined;
RuntimeRawExtension.attributeTypeMap = [
{
"name": "raw",
"baseName": "Raw",
"type": "string"
}
];
exports.RuntimeRawExtension = RuntimeRawExtension;
/**
* APIGroup contains the name, the supported versions, and the preferred version of a group.
*/
class V1APIGroup {
static getAttributeTypeMap() {
return V1APIGroup.attributeTypeMap;
}
}
V1APIGroup.discriminator = undefined;
V1APIGroup.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "preferredVersion",
"baseName": "preferredVersion",
"type": "V1GroupVersionForDiscovery"
},
{
"name": "serverAddressByClientCIDRs",
"baseName": "serverAddressByClientCIDRs",
"type": "Array"
},
{
"name": "versions",
"baseName": "versions",
"type": "Array"
}
];
exports.V1APIGroup = V1APIGroup;
/**
* APIGroupList is a list of APIGroup, to allow clients to discover the API at /apis.
*/
class V1APIGroupList {
static getAttributeTypeMap() {
return V1APIGroupList.attributeTypeMap;
}
}
V1APIGroupList.discriminator = undefined;
V1APIGroupList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "groups",
"baseName": "groups",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
}
];
exports.V1APIGroupList = V1APIGroupList;
/**
* APIResource specifies the name of a resource and whether it is namespaced.
*/
class V1APIResource {
static getAttributeTypeMap() {
return V1APIResource.attributeTypeMap;
}
}
V1APIResource.discriminator = undefined;
V1APIResource.attributeTypeMap = [
{
"name": "categories",
"baseName": "categories",
"type": "Array"
},
{
"name": "group",
"baseName": "group",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespaced",
"baseName": "namespaced",
"type": "boolean"
},
{
"name": "shortNames",
"baseName": "shortNames",
"type": "Array"
},
{
"name": "singularName",
"baseName": "singularName",
"type": "string"
},
{
"name": "verbs",
"baseName": "verbs",
"type": "Array"
},
{
"name": "version",
"baseName": "version",
"type": "string"
}
];
exports.V1APIResource = 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.
*/
class V1APIResourceList {
static getAttributeTypeMap() {
return V1APIResourceList.attributeTypeMap;
}
}
V1APIResourceList.discriminator = undefined;
V1APIResourceList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "groupVersion",
"baseName": "groupVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "resources",
"baseName": "resources",
"type": "Array"
}
];
exports.V1APIResourceList = V1APIResourceList;
/**
* APIService represents a server for a particular GroupVersion. Name must be \"version.group\".
*/
class V1APIService {
static getAttributeTypeMap() {
return V1APIService.attributeTypeMap;
}
}
V1APIService.discriminator = undefined;
V1APIService.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1APIServiceSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1APIServiceStatus"
}
];
exports.V1APIService = V1APIService;
class V1APIServiceCondition {
static getAttributeTypeMap() {
return V1APIServiceCondition.attributeTypeMap;
}
}
V1APIServiceCondition.discriminator = undefined;
V1APIServiceCondition.attributeTypeMap = [
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1APIServiceCondition = V1APIServiceCondition;
/**
* APIServiceList is a list of APIService objects.
*/
class V1APIServiceList {
static getAttributeTypeMap() {
return V1APIServiceList.attributeTypeMap;
}
}
V1APIServiceList.discriminator = undefined;
V1APIServiceList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1APIServiceList = V1APIServiceList;
/**
* APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification.
*/
class V1APIServiceSpec {
static getAttributeTypeMap() {
return V1APIServiceSpec.attributeTypeMap;
}
}
V1APIServiceSpec.discriminator = undefined;
V1APIServiceSpec.attributeTypeMap = [
{
"name": "caBundle",
"baseName": "caBundle",
"type": "string"
},
{
"name": "group",
"baseName": "group",
"type": "string"
},
{
"name": "groupPriorityMinimum",
"baseName": "groupPriorityMinimum",
"type": "number"
},
{
"name": "insecureSkipTLSVerify",
"baseName": "insecureSkipTLSVerify",
"type": "boolean"
},
{
"name": "service",
"baseName": "service",
"type": "V1ServiceReference"
},
{
"name": "version",
"baseName": "version",
"type": "string"
},
{
"name": "versionPriority",
"baseName": "versionPriority",
"type": "number"
}
];
exports.V1APIServiceSpec = V1APIServiceSpec;
/**
* APIServiceStatus contains derived information about an API server
*/
class V1APIServiceStatus {
static getAttributeTypeMap() {
return V1APIServiceStatus.attributeTypeMap;
}
}
V1APIServiceStatus.discriminator = undefined;
V1APIServiceStatus.attributeTypeMap = [
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
}
];
exports.V1APIServiceStatus = V1APIServiceStatus;
/**
* 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.
*/
class V1APIVersions {
static getAttributeTypeMap() {
return V1APIVersions.attributeTypeMap;
}
}
V1APIVersions.discriminator = undefined;
V1APIVersions.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "serverAddressByClientCIDRs",
"baseName": "serverAddressByClientCIDRs",
"type": "Array"
},
{
"name": "versions",
"baseName": "versions",
"type": "Array"
}
];
exports.V1APIVersions = V1APIVersions;
/**
* 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.
*/
class V1AWSElasticBlockStoreVolumeSource {
static getAttributeTypeMap() {
return V1AWSElasticBlockStoreVolumeSource.attributeTypeMap;
}
}
V1AWSElasticBlockStoreVolumeSource.discriminator = undefined;
V1AWSElasticBlockStoreVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "partition",
"baseName": "partition",
"type": "number"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "volumeID",
"baseName": "volumeID",
"type": "string"
}
];
exports.V1AWSElasticBlockStoreVolumeSource = V1AWSElasticBlockStoreVolumeSource;
/**
* Affinity is a group of affinity scheduling rules.
*/
class V1Affinity {
static getAttributeTypeMap() {
return V1Affinity.attributeTypeMap;
}
}
V1Affinity.discriminator = undefined;
V1Affinity.attributeTypeMap = [
{
"name": "nodeAffinity",
"baseName": "nodeAffinity",
"type": "V1NodeAffinity"
},
{
"name": "podAffinity",
"baseName": "podAffinity",
"type": "V1PodAffinity"
},
{
"name": "podAntiAffinity",
"baseName": "podAntiAffinity",
"type": "V1PodAntiAffinity"
}
];
exports.V1Affinity = V1Affinity;
/**
* AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole
*/
class V1AggregationRule {
static getAttributeTypeMap() {
return V1AggregationRule.attributeTypeMap;
}
}
V1AggregationRule.discriminator = undefined;
V1AggregationRule.attributeTypeMap = [
{
"name": "clusterRoleSelectors",
"baseName": "clusterRoleSelectors",
"type": "Array"
}
];
exports.V1AggregationRule = V1AggregationRule;
/**
* AttachedVolume describes a volume attached to a node
*/
class V1AttachedVolume {
static getAttributeTypeMap() {
return V1AttachedVolume.attributeTypeMap;
}
}
V1AttachedVolume.discriminator = undefined;
V1AttachedVolume.attributeTypeMap = [
{
"name": "devicePath",
"baseName": "devicePath",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
}
];
exports.V1AttachedVolume = V1AttachedVolume;
/**
* AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.
*/
class V1AzureDiskVolumeSource {
static getAttributeTypeMap() {
return V1AzureDiskVolumeSource.attributeTypeMap;
}
}
V1AzureDiskVolumeSource.discriminator = undefined;
V1AzureDiskVolumeSource.attributeTypeMap = [
{
"name": "cachingMode",
"baseName": "cachingMode",
"type": "string"
},
{
"name": "diskName",
"baseName": "diskName",
"type": "string"
},
{
"name": "diskURI",
"baseName": "diskURI",
"type": "string"
},
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
}
];
exports.V1AzureDiskVolumeSource = V1AzureDiskVolumeSource;
/**
* AzureFile represents an Azure File Service mount on the host and bind mount to the pod.
*/
class V1AzureFilePersistentVolumeSource {
static getAttributeTypeMap() {
return V1AzureFilePersistentVolumeSource.attributeTypeMap;
}
}
V1AzureFilePersistentVolumeSource.discriminator = undefined;
V1AzureFilePersistentVolumeSource.attributeTypeMap = [
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretName",
"baseName": "secretName",
"type": "string"
},
{
"name": "secretNamespace",
"baseName": "secretNamespace",
"type": "string"
},
{
"name": "shareName",
"baseName": "shareName",
"type": "string"
}
];
exports.V1AzureFilePersistentVolumeSource = V1AzureFilePersistentVolumeSource;
/**
* AzureFile represents an Azure File Service mount on the host and bind mount to the pod.
*/
class V1AzureFileVolumeSource {
static getAttributeTypeMap() {
return V1AzureFileVolumeSource.attributeTypeMap;
}
}
V1AzureFileVolumeSource.discriminator = undefined;
V1AzureFileVolumeSource.attributeTypeMap = [
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretName",
"baseName": "secretName",
"type": "string"
},
{
"name": "shareName",
"baseName": "shareName",
"type": "string"
}
];
exports.V1AzureFileVolumeSource = V1AzureFileVolumeSource;
/**
* 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.
*/
class V1Binding {
static getAttributeTypeMap() {
return V1Binding.attributeTypeMap;
}
}
V1Binding.discriminator = undefined;
V1Binding.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "target",
"baseName": "target",
"type": "V1ObjectReference"
}
];
exports.V1Binding = V1Binding;
/**
* Represents storage that is managed by an external CSI volume driver (Beta feature)
*/
class V1CSIPersistentVolumeSource {
static getAttributeTypeMap() {
return V1CSIPersistentVolumeSource.attributeTypeMap;
}
}
V1CSIPersistentVolumeSource.discriminator = undefined;
V1CSIPersistentVolumeSource.attributeTypeMap = [
{
"name": "controllerPublishSecretRef",
"baseName": "controllerPublishSecretRef",
"type": "V1SecretReference"
},
{
"name": "driver",
"baseName": "driver",
"type": "string"
},
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "nodePublishSecretRef",
"baseName": "nodePublishSecretRef",
"type": "V1SecretReference"
},
{
"name": "nodeStageSecretRef",
"baseName": "nodeStageSecretRef",
"type": "V1SecretReference"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "volumeAttributes",
"baseName": "volumeAttributes",
"type": "{ [key: string]: string; }"
},
{
"name": "volumeHandle",
"baseName": "volumeHandle",
"type": "string"
}
];
exports.V1CSIPersistentVolumeSource = V1CSIPersistentVolumeSource;
/**
* Adds and removes POSIX capabilities from running containers.
*/
class V1Capabilities {
static getAttributeTypeMap() {
return V1Capabilities.attributeTypeMap;
}
}
V1Capabilities.discriminator = undefined;
V1Capabilities.attributeTypeMap = [
{
"name": "add",
"baseName": "add",
"type": "Array"
},
{
"name": "drop",
"baseName": "drop",
"type": "Array"
}
];
exports.V1Capabilities = V1Capabilities;
/**
* Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.
*/
class V1CephFSPersistentVolumeSource {
static getAttributeTypeMap() {
return V1CephFSPersistentVolumeSource.attributeTypeMap;
}
}
V1CephFSPersistentVolumeSource.discriminator = undefined;
V1CephFSPersistentVolumeSource.attributeTypeMap = [
{
"name": "monitors",
"baseName": "monitors",
"type": "Array"
},
{
"name": "path",
"baseName": "path",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretFile",
"baseName": "secretFile",
"type": "string"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1SecretReference"
},
{
"name": "user",
"baseName": "user",
"type": "string"
}
];
exports.V1CephFSPersistentVolumeSource = V1CephFSPersistentVolumeSource;
/**
* Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.
*/
class V1CephFSVolumeSource {
static getAttributeTypeMap() {
return V1CephFSVolumeSource.attributeTypeMap;
}
}
V1CephFSVolumeSource.discriminator = undefined;
V1CephFSVolumeSource.attributeTypeMap = [
{
"name": "monitors",
"baseName": "monitors",
"type": "Array"
},
{
"name": "path",
"baseName": "path",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretFile",
"baseName": "secretFile",
"type": "string"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1LocalObjectReference"
},
{
"name": "user",
"baseName": "user",
"type": "string"
}
];
exports.V1CephFSVolumeSource = V1CephFSVolumeSource;
/**
* 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.
*/
class V1CinderPersistentVolumeSource {
static getAttributeTypeMap() {
return V1CinderPersistentVolumeSource.attributeTypeMap;
}
}
V1CinderPersistentVolumeSource.discriminator = undefined;
V1CinderPersistentVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1SecretReference"
},
{
"name": "volumeID",
"baseName": "volumeID",
"type": "string"
}
];
exports.V1CinderPersistentVolumeSource = V1CinderPersistentVolumeSource;
/**
* 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.
*/
class V1CinderVolumeSource {
static getAttributeTypeMap() {
return V1CinderVolumeSource.attributeTypeMap;
}
}
V1CinderVolumeSource.discriminator = undefined;
V1CinderVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1LocalObjectReference"
},
{
"name": "volumeID",
"baseName": "volumeID",
"type": "string"
}
];
exports.V1CinderVolumeSource = V1CinderVolumeSource;
/**
* ClientIPConfig represents the configurations of Client IP based session affinity.
*/
class V1ClientIPConfig {
static getAttributeTypeMap() {
return V1ClientIPConfig.attributeTypeMap;
}
}
V1ClientIPConfig.discriminator = undefined;
V1ClientIPConfig.attributeTypeMap = [
{
"name": "timeoutSeconds",
"baseName": "timeoutSeconds",
"type": "number"
}
];
exports.V1ClientIPConfig = V1ClientIPConfig;
/**
* ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding.
*/
class V1ClusterRole {
static getAttributeTypeMap() {
return V1ClusterRole.attributeTypeMap;
}
}
V1ClusterRole.discriminator = undefined;
V1ClusterRole.attributeTypeMap = [
{
"name": "aggregationRule",
"baseName": "aggregationRule",
"type": "V1AggregationRule"
},
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "rules",
"baseName": "rules",
"type": "Array"
}
];
exports.V1ClusterRole = V1ClusterRole;
/**
* ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject.
*/
class V1ClusterRoleBinding {
static getAttributeTypeMap() {
return V1ClusterRoleBinding.attributeTypeMap;
}
}
V1ClusterRoleBinding.discriminator = undefined;
V1ClusterRoleBinding.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "roleRef",
"baseName": "roleRef",
"type": "V1RoleRef"
},
{
"name": "subjects",
"baseName": "subjects",
"type": "Array"
}
];
exports.V1ClusterRoleBinding = V1ClusterRoleBinding;
/**
* ClusterRoleBindingList is a collection of ClusterRoleBindings
*/
class V1ClusterRoleBindingList {
static getAttributeTypeMap() {
return V1ClusterRoleBindingList.attributeTypeMap;
}
}
V1ClusterRoleBindingList.discriminator = undefined;
V1ClusterRoleBindingList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1ClusterRoleBindingList = V1ClusterRoleBindingList;
/**
* ClusterRoleList is a collection of ClusterRoles
*/
class V1ClusterRoleList {
static getAttributeTypeMap() {
return V1ClusterRoleList.attributeTypeMap;
}
}
V1ClusterRoleList.discriminator = undefined;
V1ClusterRoleList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1ClusterRoleList = V1ClusterRoleList;
/**
* Information about the condition of a component.
*/
class V1ComponentCondition {
static getAttributeTypeMap() {
return V1ComponentCondition.attributeTypeMap;
}
}
V1ComponentCondition.discriminator = undefined;
V1ComponentCondition.attributeTypeMap = [
{
"name": "error",
"baseName": "error",
"type": "string"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1ComponentCondition = V1ComponentCondition;
/**
* ComponentStatus (and ComponentStatusList) holds the cluster validation info.
*/
class V1ComponentStatus {
static getAttributeTypeMap() {
return V1ComponentStatus.attributeTypeMap;
}
}
V1ComponentStatus.discriminator = undefined;
V1ComponentStatus.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
}
];
exports.V1ComponentStatus = V1ComponentStatus;
/**
* Status of all the conditions for the component as a list of ComponentStatus objects.
*/
class V1ComponentStatusList {
static getAttributeTypeMap() {
return V1ComponentStatusList.attributeTypeMap;
}
}
V1ComponentStatusList.discriminator = undefined;
V1ComponentStatusList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1ComponentStatusList = V1ComponentStatusList;
/**
* ConfigMap holds configuration data for pods to consume.
*/
class V1ConfigMap {
static getAttributeTypeMap() {
return V1ConfigMap.attributeTypeMap;
}
}
V1ConfigMap.discriminator = undefined;
V1ConfigMap.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "binaryData",
"baseName": "binaryData",
"type": "{ [key: string]: string; }"
},
{
"name": "data",
"baseName": "data",
"type": "{ [key: string]: string; }"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
}
];
exports.V1ConfigMap = V1ConfigMap;
/**
* 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.
*/
class V1ConfigMapEnvSource {
static getAttributeTypeMap() {
return V1ConfigMapEnvSource.attributeTypeMap;
}
}
V1ConfigMapEnvSource.discriminator = undefined;
V1ConfigMapEnvSource.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "optional",
"baseName": "optional",
"type": "boolean"
}
];
exports.V1ConfigMapEnvSource = V1ConfigMapEnvSource;
/**
* Selects a key from a ConfigMap.
*/
class V1ConfigMapKeySelector {
static getAttributeTypeMap() {
return V1ConfigMapKeySelector.attributeTypeMap;
}
}
V1ConfigMapKeySelector.discriminator = undefined;
V1ConfigMapKeySelector.attributeTypeMap = [
{
"name": "key",
"baseName": "key",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "optional",
"baseName": "optional",
"type": "boolean"
}
];
exports.V1ConfigMapKeySelector = V1ConfigMapKeySelector;
/**
* ConfigMapList is a resource containing a list of ConfigMap objects.
*/
class V1ConfigMapList {
static getAttributeTypeMap() {
return V1ConfigMapList.attributeTypeMap;
}
}
V1ConfigMapList.discriminator = undefined;
V1ConfigMapList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1ConfigMapList = V1ConfigMapList;
/**
* ConfigMapNodeConfigSource contains the information to reference a ConfigMap as a config source for the Node.
*/
class V1ConfigMapNodeConfigSource {
static getAttributeTypeMap() {
return V1ConfigMapNodeConfigSource.attributeTypeMap;
}
}
V1ConfigMapNodeConfigSource.discriminator = undefined;
V1ConfigMapNodeConfigSource.attributeTypeMap = [
{
"name": "kubeletConfigKey",
"baseName": "kubeletConfigKey",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
},
{
"name": "resourceVersion",
"baseName": "resourceVersion",
"type": "string"
},
{
"name": "uid",
"baseName": "uid",
"type": "string"
}
];
exports.V1ConfigMapNodeConfigSource = V1ConfigMapNodeConfigSource;
/**
* 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.
*/
class V1ConfigMapProjection {
static getAttributeTypeMap() {
return V1ConfigMapProjection.attributeTypeMap;
}
}
V1ConfigMapProjection.discriminator = undefined;
V1ConfigMapProjection.attributeTypeMap = [
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "optional",
"baseName": "optional",
"type": "boolean"
}
];
exports.V1ConfigMapProjection = V1ConfigMapProjection;
/**
* 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.
*/
class V1ConfigMapVolumeSource {
static getAttributeTypeMap() {
return V1ConfigMapVolumeSource.attributeTypeMap;
}
}
V1ConfigMapVolumeSource.discriminator = undefined;
V1ConfigMapVolumeSource.attributeTypeMap = [
{
"name": "defaultMode",
"baseName": "defaultMode",
"type": "number"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "optional",
"baseName": "optional",
"type": "boolean"
}
];
exports.V1ConfigMapVolumeSource = V1ConfigMapVolumeSource;
/**
* A single application container that you want to run within a pod.
*/
class V1Container {
static getAttributeTypeMap() {
return V1Container.attributeTypeMap;
}
}
V1Container.discriminator = undefined;
V1Container.attributeTypeMap = [
{
"name": "args",
"baseName": "args",
"type": "Array"
},
{
"name": "command",
"baseName": "command",
"type": "Array"
},
{
"name": "env",
"baseName": "env",
"type": "Array"
},
{
"name": "envFrom",
"baseName": "envFrom",
"type": "Array"
},
{
"name": "image",
"baseName": "image",
"type": "string"
},
{
"name": "imagePullPolicy",
"baseName": "imagePullPolicy",
"type": "string"
},
{
"name": "lifecycle",
"baseName": "lifecycle",
"type": "V1Lifecycle"
},
{
"name": "livenessProbe",
"baseName": "livenessProbe",
"type": "V1Probe"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "ports",
"baseName": "ports",
"type": "Array"
},
{
"name": "readinessProbe",
"baseName": "readinessProbe",
"type": "V1Probe"
},
{
"name": "resources",
"baseName": "resources",
"type": "V1ResourceRequirements"
},
{
"name": "securityContext",
"baseName": "securityContext",
"type": "V1SecurityContext"
},
{
"name": "stdin",
"baseName": "stdin",
"type": "boolean"
},
{
"name": "stdinOnce",
"baseName": "stdinOnce",
"type": "boolean"
},
{
"name": "terminationMessagePath",
"baseName": "terminationMessagePath",
"type": "string"
},
{
"name": "terminationMessagePolicy",
"baseName": "terminationMessagePolicy",
"type": "string"
},
{
"name": "tty",
"baseName": "tty",
"type": "boolean"
},
{
"name": "volumeDevices",
"baseName": "volumeDevices",
"type": "Array"
},
{
"name": "volumeMounts",
"baseName": "volumeMounts",
"type": "Array"
},
{
"name": "workingDir",
"baseName": "workingDir",
"type": "string"
}
];
exports.V1Container = V1Container;
/**
* Describe a container image
*/
class V1ContainerImage {
static getAttributeTypeMap() {
return V1ContainerImage.attributeTypeMap;
}
}
V1ContainerImage.discriminator = undefined;
V1ContainerImage.attributeTypeMap = [
{
"name": "names",
"baseName": "names",
"type": "Array"
},
{
"name": "sizeBytes",
"baseName": "sizeBytes",
"type": "number"
}
];
exports.V1ContainerImage = V1ContainerImage;
/**
* ContainerPort represents a network port in a single container.
*/
class V1ContainerPort {
static getAttributeTypeMap() {
return V1ContainerPort.attributeTypeMap;
}
}
V1ContainerPort.discriminator = undefined;
V1ContainerPort.attributeTypeMap = [
{
"name": "containerPort",
"baseName": "containerPort",
"type": "number"
},
{
"name": "hostIP",
"baseName": "hostIP",
"type": "string"
},
{
"name": "hostPort",
"baseName": "hostPort",
"type": "number"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "protocol",
"baseName": "protocol",
"type": "string"
}
];
exports.V1ContainerPort = V1ContainerPort;
/**
* 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.
*/
class V1ContainerState {
static getAttributeTypeMap() {
return V1ContainerState.attributeTypeMap;
}
}
V1ContainerState.discriminator = undefined;
V1ContainerState.attributeTypeMap = [
{
"name": "running",
"baseName": "running",
"type": "V1ContainerStateRunning"
},
{
"name": "terminated",
"baseName": "terminated",
"type": "V1ContainerStateTerminated"
},
{
"name": "waiting",
"baseName": "waiting",
"type": "V1ContainerStateWaiting"
}
];
exports.V1ContainerState = V1ContainerState;
/**
* ContainerStateRunning is a running state of a container.
*/
class V1ContainerStateRunning {
static getAttributeTypeMap() {
return V1ContainerStateRunning.attributeTypeMap;
}
}
V1ContainerStateRunning.discriminator = undefined;
V1ContainerStateRunning.attributeTypeMap = [
{
"name": "startedAt",
"baseName": "startedAt",
"type": "Date"
}
];
exports.V1ContainerStateRunning = V1ContainerStateRunning;
/**
* ContainerStateTerminated is a terminated state of a container.
*/
class V1ContainerStateTerminated {
static getAttributeTypeMap() {
return V1ContainerStateTerminated.attributeTypeMap;
}
}
V1ContainerStateTerminated.discriminator = undefined;
V1ContainerStateTerminated.attributeTypeMap = [
{
"name": "containerID",
"baseName": "containerID",
"type": "string"
},
{
"name": "exitCode",
"baseName": "exitCode",
"type": "number"
},
{
"name": "finishedAt",
"baseName": "finishedAt",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "signal",
"baseName": "signal",
"type": "number"
},
{
"name": "startedAt",
"baseName": "startedAt",
"type": "Date"
}
];
exports.V1ContainerStateTerminated = V1ContainerStateTerminated;
/**
* ContainerStateWaiting is a waiting state of a container.
*/
class V1ContainerStateWaiting {
static getAttributeTypeMap() {
return V1ContainerStateWaiting.attributeTypeMap;
}
}
V1ContainerStateWaiting.discriminator = undefined;
V1ContainerStateWaiting.attributeTypeMap = [
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
}
];
exports.V1ContainerStateWaiting = V1ContainerStateWaiting;
/**
* ContainerStatus contains details for the current status of this container.
*/
class V1ContainerStatus {
static getAttributeTypeMap() {
return V1ContainerStatus.attributeTypeMap;
}
}
V1ContainerStatus.discriminator = undefined;
V1ContainerStatus.attributeTypeMap = [
{
"name": "containerID",
"baseName": "containerID",
"type": "string"
},
{
"name": "image",
"baseName": "image",
"type": "string"
},
{
"name": "imageID",
"baseName": "imageID",
"type": "string"
},
{
"name": "lastState",
"baseName": "lastState",
"type": "V1ContainerState"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "ready",
"baseName": "ready",
"type": "boolean"
},
{
"name": "restartCount",
"baseName": "restartCount",
"type": "number"
},
{
"name": "state",
"baseName": "state",
"type": "V1ContainerState"
}
];
exports.V1ContainerStatus = V1ContainerStatus;
/**
* 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.
*/
class V1ControllerRevision {
static getAttributeTypeMap() {
return V1ControllerRevision.attributeTypeMap;
}
}
V1ControllerRevision.discriminator = undefined;
V1ControllerRevision.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "data",
"baseName": "data",
"type": "RuntimeRawExtension"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "revision",
"baseName": "revision",
"type": "number"
}
];
exports.V1ControllerRevision = V1ControllerRevision;
/**
* ControllerRevisionList is a resource containing a list of ControllerRevision objects.
*/
class V1ControllerRevisionList {
static getAttributeTypeMap() {
return V1ControllerRevisionList.attributeTypeMap;
}
}
V1ControllerRevisionList.discriminator = undefined;
V1ControllerRevisionList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1ControllerRevisionList = V1ControllerRevisionList;
/**
* CrossVersionObjectReference contains enough information to let you identify the referred resource.
*/
class V1CrossVersionObjectReference {
static getAttributeTypeMap() {
return V1CrossVersionObjectReference.attributeTypeMap;
}
}
V1CrossVersionObjectReference.discriminator = undefined;
V1CrossVersionObjectReference.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
}
];
exports.V1CrossVersionObjectReference = V1CrossVersionObjectReference;
/**
* DaemonEndpoint contains information about a single Daemon endpoint.
*/
class V1DaemonEndpoint {
static getAttributeTypeMap() {
return V1DaemonEndpoint.attributeTypeMap;
}
}
V1DaemonEndpoint.discriminator = undefined;
V1DaemonEndpoint.attributeTypeMap = [
{
"name": "port",
"baseName": "Port",
"type": "number"
}
];
exports.V1DaemonEndpoint = V1DaemonEndpoint;
/**
* DaemonSet represents the configuration of a daemon set.
*/
class V1DaemonSet {
static getAttributeTypeMap() {
return V1DaemonSet.attributeTypeMap;
}
}
V1DaemonSet.discriminator = undefined;
V1DaemonSet.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1DaemonSetSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1DaemonSetStatus"
}
];
exports.V1DaemonSet = V1DaemonSet;
/**
* DaemonSetCondition describes the state of a DaemonSet at a certain point.
*/
class V1DaemonSetCondition {
static getAttributeTypeMap() {
return V1DaemonSetCondition.attributeTypeMap;
}
}
V1DaemonSetCondition.discriminator = undefined;
V1DaemonSetCondition.attributeTypeMap = [
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1DaemonSetCondition = V1DaemonSetCondition;
/**
* DaemonSetList is a collection of daemon sets.
*/
class V1DaemonSetList {
static getAttributeTypeMap() {
return V1DaemonSetList.attributeTypeMap;
}
}
V1DaemonSetList.discriminator = undefined;
V1DaemonSetList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1DaemonSetList = V1DaemonSetList;
/**
* DaemonSetSpec is the specification of a daemon set.
*/
class V1DaemonSetSpec {
static getAttributeTypeMap() {
return V1DaemonSetSpec.attributeTypeMap;
}
}
V1DaemonSetSpec.discriminator = undefined;
V1DaemonSetSpec.attributeTypeMap = [
{
"name": "minReadySeconds",
"baseName": "minReadySeconds",
"type": "number"
},
{
"name": "revisionHistoryLimit",
"baseName": "revisionHistoryLimit",
"type": "number"
},
{
"name": "selector",
"baseName": "selector",
"type": "V1LabelSelector"
},
{
"name": "template",
"baseName": "template",
"type": "V1PodTemplateSpec"
},
{
"name": "updateStrategy",
"baseName": "updateStrategy",
"type": "V1DaemonSetUpdateStrategy"
}
];
exports.V1DaemonSetSpec = V1DaemonSetSpec;
/**
* DaemonSetStatus represents the current status of a daemon set.
*/
class V1DaemonSetStatus {
static getAttributeTypeMap() {
return V1DaemonSetStatus.attributeTypeMap;
}
}
V1DaemonSetStatus.discriminator = undefined;
V1DaemonSetStatus.attributeTypeMap = [
{
"name": "collisionCount",
"baseName": "collisionCount",
"type": "number"
},
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "currentNumberScheduled",
"baseName": "currentNumberScheduled",
"type": "number"
},
{
"name": "desiredNumberScheduled",
"baseName": "desiredNumberScheduled",
"type": "number"
},
{
"name": "numberAvailable",
"baseName": "numberAvailable",
"type": "number"
},
{
"name": "numberMisscheduled",
"baseName": "numberMisscheduled",
"type": "number"
},
{
"name": "numberReady",
"baseName": "numberReady",
"type": "number"
},
{
"name": "numberUnavailable",
"baseName": "numberUnavailable",
"type": "number"
},
{
"name": "observedGeneration",
"baseName": "observedGeneration",
"type": "number"
},
{
"name": "updatedNumberScheduled",
"baseName": "updatedNumberScheduled",
"type": "number"
}
];
exports.V1DaemonSetStatus = V1DaemonSetStatus;
/**
* DaemonSetUpdateStrategy is a struct used to control the update strategy for a DaemonSet.
*/
class V1DaemonSetUpdateStrategy {
static getAttributeTypeMap() {
return V1DaemonSetUpdateStrategy.attributeTypeMap;
}
}
V1DaemonSetUpdateStrategy.discriminator = undefined;
V1DaemonSetUpdateStrategy.attributeTypeMap = [
{
"name": "rollingUpdate",
"baseName": "rollingUpdate",
"type": "V1RollingUpdateDaemonSet"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1DaemonSetUpdateStrategy = V1DaemonSetUpdateStrategy;
/**
* DeleteOptions may be provided when deleting an API object.
*/
class V1DeleteOptions {
static getAttributeTypeMap() {
return V1DeleteOptions.attributeTypeMap;
}
}
V1DeleteOptions.discriminator = undefined;
V1DeleteOptions.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "dryRun",
"baseName": "dryRun",
"type": "Array"
},
{
"name": "gracePeriodSeconds",
"baseName": "gracePeriodSeconds",
"type": "number"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "orphanDependents",
"baseName": "orphanDependents",
"type": "boolean"
},
{
"name": "preconditions",
"baseName": "preconditions",
"type": "V1Preconditions"
},
{
"name": "propagationPolicy",
"baseName": "propagationPolicy",
"type": "string"
}
];
exports.V1DeleteOptions = V1DeleteOptions;
/**
* Deployment enables declarative updates for Pods and ReplicaSets.
*/
class V1Deployment {
static getAttributeTypeMap() {
return V1Deployment.attributeTypeMap;
}
}
V1Deployment.discriminator = undefined;
V1Deployment.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1DeploymentSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1DeploymentStatus"
}
];
exports.V1Deployment = V1Deployment;
/**
* DeploymentCondition describes the state of a deployment at a certain point.
*/
class V1DeploymentCondition {
static getAttributeTypeMap() {
return V1DeploymentCondition.attributeTypeMap;
}
}
V1DeploymentCondition.discriminator = undefined;
V1DeploymentCondition.attributeTypeMap = [
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "lastUpdateTime",
"baseName": "lastUpdateTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1DeploymentCondition = V1DeploymentCondition;
/**
* DeploymentList is a list of Deployments.
*/
class V1DeploymentList {
static getAttributeTypeMap() {
return V1DeploymentList.attributeTypeMap;
}
}
V1DeploymentList.discriminator = undefined;
V1DeploymentList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1DeploymentList = V1DeploymentList;
/**
* DeploymentSpec is the specification of the desired behavior of the Deployment.
*/
class V1DeploymentSpec {
static getAttributeTypeMap() {
return V1DeploymentSpec.attributeTypeMap;
}
}
V1DeploymentSpec.discriminator = undefined;
V1DeploymentSpec.attributeTypeMap = [
{
"name": "minReadySeconds",
"baseName": "minReadySeconds",
"type": "number"
},
{
"name": "paused",
"baseName": "paused",
"type": "boolean"
},
{
"name": "progressDeadlineSeconds",
"baseName": "progressDeadlineSeconds",
"type": "number"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "revisionHistoryLimit",
"baseName": "revisionHistoryLimit",
"type": "number"
},
{
"name": "selector",
"baseName": "selector",
"type": "V1LabelSelector"
},
{
"name": "strategy",
"baseName": "strategy",
"type": "V1DeploymentStrategy"
},
{
"name": "template",
"baseName": "template",
"type": "V1PodTemplateSpec"
}
];
exports.V1DeploymentSpec = V1DeploymentSpec;
/**
* DeploymentStatus is the most recently observed status of the Deployment.
*/
class V1DeploymentStatus {
static getAttributeTypeMap() {
return V1DeploymentStatus.attributeTypeMap;
}
}
V1DeploymentStatus.discriminator = undefined;
V1DeploymentStatus.attributeTypeMap = [
{
"name": "availableReplicas",
"baseName": "availableReplicas",
"type": "number"
},
{
"name": "collisionCount",
"baseName": "collisionCount",
"type": "number"
},
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "observedGeneration",
"baseName": "observedGeneration",
"type": "number"
},
{
"name": "readyReplicas",
"baseName": "readyReplicas",
"type": "number"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "unavailableReplicas",
"baseName": "unavailableReplicas",
"type": "number"
},
{
"name": "updatedReplicas",
"baseName": "updatedReplicas",
"type": "number"
}
];
exports.V1DeploymentStatus = V1DeploymentStatus;
/**
* DeploymentStrategy describes how to replace existing pods with new ones.
*/
class V1DeploymentStrategy {
static getAttributeTypeMap() {
return V1DeploymentStrategy.attributeTypeMap;
}
}
V1DeploymentStrategy.discriminator = undefined;
V1DeploymentStrategy.attributeTypeMap = [
{
"name": "rollingUpdate",
"baseName": "rollingUpdate",
"type": "V1RollingUpdateDeployment"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1DeploymentStrategy = V1DeploymentStrategy;
/**
* Represents downward API info for projecting into a projected volume. Note that this is identical to a downwardAPI volume source without the default mode.
*/
class V1DownwardAPIProjection {
static getAttributeTypeMap() {
return V1DownwardAPIProjection.attributeTypeMap;
}
}
V1DownwardAPIProjection.discriminator = undefined;
V1DownwardAPIProjection.attributeTypeMap = [
{
"name": "items",
"baseName": "items",
"type": "Array"
}
];
exports.V1DownwardAPIProjection = V1DownwardAPIProjection;
/**
* DownwardAPIVolumeFile represents information to create the file containing the pod field
*/
class V1DownwardAPIVolumeFile {
static getAttributeTypeMap() {
return V1DownwardAPIVolumeFile.attributeTypeMap;
}
}
V1DownwardAPIVolumeFile.discriminator = undefined;
V1DownwardAPIVolumeFile.attributeTypeMap = [
{
"name": "fieldRef",
"baseName": "fieldRef",
"type": "V1ObjectFieldSelector"
},
{
"name": "mode",
"baseName": "mode",
"type": "number"
},
{
"name": "path",
"baseName": "path",
"type": "string"
},
{
"name": "resourceFieldRef",
"baseName": "resourceFieldRef",
"type": "V1ResourceFieldSelector"
}
];
exports.V1DownwardAPIVolumeFile = V1DownwardAPIVolumeFile;
/**
* DownwardAPIVolumeSource represents a volume containing downward API info. Downward API volumes support ownership management and SELinux relabeling.
*/
class V1DownwardAPIVolumeSource {
static getAttributeTypeMap() {
return V1DownwardAPIVolumeSource.attributeTypeMap;
}
}
V1DownwardAPIVolumeSource.discriminator = undefined;
V1DownwardAPIVolumeSource.attributeTypeMap = [
{
"name": "defaultMode",
"baseName": "defaultMode",
"type": "number"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
}
];
exports.V1DownwardAPIVolumeSource = V1DownwardAPIVolumeSource;
/**
* Represents an empty directory for a pod. Empty directory volumes support ownership management and SELinux relabeling.
*/
class V1EmptyDirVolumeSource {
static getAttributeTypeMap() {
return V1EmptyDirVolumeSource.attributeTypeMap;
}
}
V1EmptyDirVolumeSource.discriminator = undefined;
V1EmptyDirVolumeSource.attributeTypeMap = [
{
"name": "medium",
"baseName": "medium",
"type": "string"
},
{
"name": "sizeLimit",
"baseName": "sizeLimit",
"type": "string"
}
];
exports.V1EmptyDirVolumeSource = V1EmptyDirVolumeSource;
/**
* EndpointAddress is a tuple that describes single IP address.
*/
class V1EndpointAddress {
static getAttributeTypeMap() {
return V1EndpointAddress.attributeTypeMap;
}
}
V1EndpointAddress.discriminator = undefined;
V1EndpointAddress.attributeTypeMap = [
{
"name": "hostname",
"baseName": "hostname",
"type": "string"
},
{
"name": "ip",
"baseName": "ip",
"type": "string"
},
{
"name": "nodeName",
"baseName": "nodeName",
"type": "string"
},
{
"name": "targetRef",
"baseName": "targetRef",
"type": "V1ObjectReference"
}
];
exports.V1EndpointAddress = V1EndpointAddress;
/**
* EndpointPort is a tuple that describes a single port.
*/
class V1EndpointPort {
static getAttributeTypeMap() {
return V1EndpointPort.attributeTypeMap;
}
}
V1EndpointPort.discriminator = undefined;
V1EndpointPort.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "port",
"baseName": "port",
"type": "number"
},
{
"name": "protocol",
"baseName": "protocol",
"type": "string"
}
];
exports.V1EndpointPort = 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 ]
*/
class V1EndpointSubset {
static getAttributeTypeMap() {
return V1EndpointSubset.attributeTypeMap;
}
}
V1EndpointSubset.discriminator = undefined;
V1EndpointSubset.attributeTypeMap = [
{
"name": "addresses",
"baseName": "addresses",
"type": "Array"
},
{
"name": "notReadyAddresses",
"baseName": "notReadyAddresses",
"type": "Array"
},
{
"name": "ports",
"baseName": "ports",
"type": "Array"
}
];
exports.V1EndpointSubset = V1EndpointSubset;
/**
* 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}] }, ]
*/
class V1Endpoints {
static getAttributeTypeMap() {
return V1Endpoints.attributeTypeMap;
}
}
V1Endpoints.discriminator = undefined;
V1Endpoints.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "subsets",
"baseName": "subsets",
"type": "Array"
}
];
exports.V1Endpoints = V1Endpoints;
/**
* EndpointsList is a list of endpoints.
*/
class V1EndpointsList {
static getAttributeTypeMap() {
return V1EndpointsList.attributeTypeMap;
}
}
V1EndpointsList.discriminator = undefined;
V1EndpointsList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1EndpointsList = V1EndpointsList;
/**
* EnvFromSource represents the source of a set of ConfigMaps
*/
class V1EnvFromSource {
static getAttributeTypeMap() {
return V1EnvFromSource.attributeTypeMap;
}
}
V1EnvFromSource.discriminator = undefined;
V1EnvFromSource.attributeTypeMap = [
{
"name": "configMapRef",
"baseName": "configMapRef",
"type": "V1ConfigMapEnvSource"
},
{
"name": "prefix",
"baseName": "prefix",
"type": "string"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1SecretEnvSource"
}
];
exports.V1EnvFromSource = V1EnvFromSource;
/**
* EnvVar represents an environment variable present in a Container.
*/
class V1EnvVar {
static getAttributeTypeMap() {
return V1EnvVar.attributeTypeMap;
}
}
V1EnvVar.discriminator = undefined;
V1EnvVar.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "value",
"baseName": "value",
"type": "string"
},
{
"name": "valueFrom",
"baseName": "valueFrom",
"type": "V1EnvVarSource"
}
];
exports.V1EnvVar = V1EnvVar;
/**
* EnvVarSource represents a source for the value of an EnvVar.
*/
class V1EnvVarSource {
static getAttributeTypeMap() {
return V1EnvVarSource.attributeTypeMap;
}
}
V1EnvVarSource.discriminator = undefined;
V1EnvVarSource.attributeTypeMap = [
{
"name": "configMapKeyRef",
"baseName": "configMapKeyRef",
"type": "V1ConfigMapKeySelector"
},
{
"name": "fieldRef",
"baseName": "fieldRef",
"type": "V1ObjectFieldSelector"
},
{
"name": "resourceFieldRef",
"baseName": "resourceFieldRef",
"type": "V1ResourceFieldSelector"
},
{
"name": "secretKeyRef",
"baseName": "secretKeyRef",
"type": "V1SecretKeySelector"
}
];
exports.V1EnvVarSource = V1EnvVarSource;
/**
* Event is a report of an event somewhere in the cluster.
*/
class V1Event {
static getAttributeTypeMap() {
return V1Event.attributeTypeMap;
}
}
V1Event.discriminator = undefined;
V1Event.attributeTypeMap = [
{
"name": "action",
"baseName": "action",
"type": "string"
},
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "count",
"baseName": "count",
"type": "number"
},
{
"name": "eventTime",
"baseName": "eventTime",
"type": "Date"
},
{
"name": "firstTimestamp",
"baseName": "firstTimestamp",
"type": "Date"
},
{
"name": "involvedObject",
"baseName": "involvedObject",
"type": "V1ObjectReference"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "lastTimestamp",
"baseName": "lastTimestamp",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "related",
"baseName": "related",
"type": "V1ObjectReference"
},
{
"name": "reportingComponent",
"baseName": "reportingComponent",
"type": "string"
},
{
"name": "reportingInstance",
"baseName": "reportingInstance",
"type": "string"
},
{
"name": "series",
"baseName": "series",
"type": "V1EventSeries"
},
{
"name": "source",
"baseName": "source",
"type": "V1EventSource"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1Event = V1Event;
/**
* EventList is a list of events.
*/
class V1EventList {
static getAttributeTypeMap() {
return V1EventList.attributeTypeMap;
}
}
V1EventList.discriminator = undefined;
V1EventList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1EventList = V1EventList;
/**
* EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time.
*/
class V1EventSeries {
static getAttributeTypeMap() {
return V1EventSeries.attributeTypeMap;
}
}
V1EventSeries.discriminator = undefined;
V1EventSeries.attributeTypeMap = [
{
"name": "count",
"baseName": "count",
"type": "number"
},
{
"name": "lastObservedTime",
"baseName": "lastObservedTime",
"type": "Date"
},
{
"name": "state",
"baseName": "state",
"type": "string"
}
];
exports.V1EventSeries = V1EventSeries;
/**
* EventSource contains information for an event.
*/
class V1EventSource {
static getAttributeTypeMap() {
return V1EventSource.attributeTypeMap;
}
}
V1EventSource.discriminator = undefined;
V1EventSource.attributeTypeMap = [
{
"name": "component",
"baseName": "component",
"type": "string"
},
{
"name": "host",
"baseName": "host",
"type": "string"
}
];
exports.V1EventSource = V1EventSource;
/**
* ExecAction describes a \"run in container\" action.
*/
class V1ExecAction {
static getAttributeTypeMap() {
return V1ExecAction.attributeTypeMap;
}
}
V1ExecAction.discriminator = undefined;
V1ExecAction.attributeTypeMap = [
{
"name": "command",
"baseName": "command",
"type": "Array"
}
];
exports.V1ExecAction = V1ExecAction;
/**
* 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.
*/
class V1FCVolumeSource {
static getAttributeTypeMap() {
return V1FCVolumeSource.attributeTypeMap;
}
}
V1FCVolumeSource.discriminator = undefined;
V1FCVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "lun",
"baseName": "lun",
"type": "number"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "targetWWNs",
"baseName": "targetWWNs",
"type": "Array"
},
{
"name": "wwids",
"baseName": "wwids",
"type": "Array"
}
];
exports.V1FCVolumeSource = V1FCVolumeSource;
/**
* FlexPersistentVolumeSource represents a generic persistent volume resource that is provisioned/attached using an exec based plugin.
*/
class V1FlexPersistentVolumeSource {
static getAttributeTypeMap() {
return V1FlexPersistentVolumeSource.attributeTypeMap;
}
}
V1FlexPersistentVolumeSource.discriminator = undefined;
V1FlexPersistentVolumeSource.attributeTypeMap = [
{
"name": "driver",
"baseName": "driver",
"type": "string"
},
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "options",
"baseName": "options",
"type": "{ [key: string]: string; }"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1SecretReference"
}
];
exports.V1FlexPersistentVolumeSource = V1FlexPersistentVolumeSource;
/**
* FlexVolume represents a generic volume resource that is provisioned/attached using an exec based plugin.
*/
class V1FlexVolumeSource {
static getAttributeTypeMap() {
return V1FlexVolumeSource.attributeTypeMap;
}
}
V1FlexVolumeSource.discriminator = undefined;
V1FlexVolumeSource.attributeTypeMap = [
{
"name": "driver",
"baseName": "driver",
"type": "string"
},
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "options",
"baseName": "options",
"type": "{ [key: string]: string; }"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1LocalObjectReference"
}
];
exports.V1FlexVolumeSource = V1FlexVolumeSource;
/**
* 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.
*/
class V1FlockerVolumeSource {
static getAttributeTypeMap() {
return V1FlockerVolumeSource.attributeTypeMap;
}
}
V1FlockerVolumeSource.discriminator = undefined;
V1FlockerVolumeSource.attributeTypeMap = [
{
"name": "datasetName",
"baseName": "datasetName",
"type": "string"
},
{
"name": "datasetUUID",
"baseName": "datasetUUID",
"type": "string"
}
];
exports.V1FlockerVolumeSource = V1FlockerVolumeSource;
/**
* 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.
*/
class V1GCEPersistentDiskVolumeSource {
static getAttributeTypeMap() {
return V1GCEPersistentDiskVolumeSource.attributeTypeMap;
}
}
V1GCEPersistentDiskVolumeSource.discriminator = undefined;
V1GCEPersistentDiskVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "partition",
"baseName": "partition",
"type": "number"
},
{
"name": "pdName",
"baseName": "pdName",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
}
];
exports.V1GCEPersistentDiskVolumeSource = V1GCEPersistentDiskVolumeSource;
/**
* 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.
*/
class V1GitRepoVolumeSource {
static getAttributeTypeMap() {
return V1GitRepoVolumeSource.attributeTypeMap;
}
}
V1GitRepoVolumeSource.discriminator = undefined;
V1GitRepoVolumeSource.attributeTypeMap = [
{
"name": "directory",
"baseName": "directory",
"type": "string"
},
{
"name": "repository",
"baseName": "repository",
"type": "string"
},
{
"name": "revision",
"baseName": "revision",
"type": "string"
}
];
exports.V1GitRepoVolumeSource = V1GitRepoVolumeSource;
/**
* Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.
*/
class V1GlusterfsPersistentVolumeSource {
static getAttributeTypeMap() {
return V1GlusterfsPersistentVolumeSource.attributeTypeMap;
}
}
V1GlusterfsPersistentVolumeSource.discriminator = undefined;
V1GlusterfsPersistentVolumeSource.attributeTypeMap = [
{
"name": "endpoints",
"baseName": "endpoints",
"type": "string"
},
{
"name": "endpointsNamespace",
"baseName": "endpointsNamespace",
"type": "string"
},
{
"name": "path",
"baseName": "path",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
}
];
exports.V1GlusterfsPersistentVolumeSource = V1GlusterfsPersistentVolumeSource;
/**
* Represents a Glusterfs mount that lasts the lifetime of a pod. Glusterfs volumes do not support ownership management or SELinux relabeling.
*/
class V1GlusterfsVolumeSource {
static getAttributeTypeMap() {
return V1GlusterfsVolumeSource.attributeTypeMap;
}
}
V1GlusterfsVolumeSource.discriminator = undefined;
V1GlusterfsVolumeSource.attributeTypeMap = [
{
"name": "endpoints",
"baseName": "endpoints",
"type": "string"
},
{
"name": "path",
"baseName": "path",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
}
];
exports.V1GlusterfsVolumeSource = V1GlusterfsVolumeSource;
/**
* GroupVersion contains the \"group/version\" and \"version\" string of a version. It is made a struct to keep extensibility.
*/
class V1GroupVersionForDiscovery {
static getAttributeTypeMap() {
return V1GroupVersionForDiscovery.attributeTypeMap;
}
}
V1GroupVersionForDiscovery.discriminator = undefined;
V1GroupVersionForDiscovery.attributeTypeMap = [
{
"name": "groupVersion",
"baseName": "groupVersion",
"type": "string"
},
{
"name": "version",
"baseName": "version",
"type": "string"
}
];
exports.V1GroupVersionForDiscovery = V1GroupVersionForDiscovery;
/**
* HTTPGetAction describes an action based on HTTP Get requests.
*/
class V1HTTPGetAction {
static getAttributeTypeMap() {
return V1HTTPGetAction.attributeTypeMap;
}
}
V1HTTPGetAction.discriminator = undefined;
V1HTTPGetAction.attributeTypeMap = [
{
"name": "host",
"baseName": "host",
"type": "string"
},
{
"name": "httpHeaders",
"baseName": "httpHeaders",
"type": "Array"
},
{
"name": "path",
"baseName": "path",
"type": "string"
},
{
"name": "port",
"baseName": "port",
"type": "any"
},
{
"name": "scheme",
"baseName": "scheme",
"type": "string"
}
];
exports.V1HTTPGetAction = V1HTTPGetAction;
/**
* HTTPHeader describes a custom header to be used in HTTP probes
*/
class V1HTTPHeader {
static getAttributeTypeMap() {
return V1HTTPHeader.attributeTypeMap;
}
}
V1HTTPHeader.discriminator = undefined;
V1HTTPHeader.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "value",
"baseName": "value",
"type": "string"
}
];
exports.V1HTTPHeader = V1HTTPHeader;
/**
* Handler defines a specific action that should be taken
*/
class V1Handler {
static getAttributeTypeMap() {
return V1Handler.attributeTypeMap;
}
}
V1Handler.discriminator = undefined;
V1Handler.attributeTypeMap = [
{
"name": "exec",
"baseName": "exec",
"type": "V1ExecAction"
},
{
"name": "httpGet",
"baseName": "httpGet",
"type": "V1HTTPGetAction"
},
{
"name": "tcpSocket",
"baseName": "tcpSocket",
"type": "V1TCPSocketAction"
}
];
exports.V1Handler = V1Handler;
/**
* configuration of a horizontal pod autoscaler.
*/
class V1HorizontalPodAutoscaler {
static getAttributeTypeMap() {
return V1HorizontalPodAutoscaler.attributeTypeMap;
}
}
V1HorizontalPodAutoscaler.discriminator = undefined;
V1HorizontalPodAutoscaler.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1HorizontalPodAutoscalerSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1HorizontalPodAutoscalerStatus"
}
];
exports.V1HorizontalPodAutoscaler = V1HorizontalPodAutoscaler;
/**
* list of horizontal pod autoscaler objects.
*/
class V1HorizontalPodAutoscalerList {
static getAttributeTypeMap() {
return V1HorizontalPodAutoscalerList.attributeTypeMap;
}
}
V1HorizontalPodAutoscalerList.discriminator = undefined;
V1HorizontalPodAutoscalerList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1HorizontalPodAutoscalerList = V1HorizontalPodAutoscalerList;
/**
* specification of a horizontal pod autoscaler.
*/
class V1HorizontalPodAutoscalerSpec {
static getAttributeTypeMap() {
return V1HorizontalPodAutoscalerSpec.attributeTypeMap;
}
}
V1HorizontalPodAutoscalerSpec.discriminator = undefined;
V1HorizontalPodAutoscalerSpec.attributeTypeMap = [
{
"name": "maxReplicas",
"baseName": "maxReplicas",
"type": "number"
},
{
"name": "minReplicas",
"baseName": "minReplicas",
"type": "number"
},
{
"name": "scaleTargetRef",
"baseName": "scaleTargetRef",
"type": "V1CrossVersionObjectReference"
},
{
"name": "targetCPUUtilizationPercentage",
"baseName": "targetCPUUtilizationPercentage",
"type": "number"
}
];
exports.V1HorizontalPodAutoscalerSpec = V1HorizontalPodAutoscalerSpec;
/**
* current status of a horizontal pod autoscaler
*/
class V1HorizontalPodAutoscalerStatus {
static getAttributeTypeMap() {
return V1HorizontalPodAutoscalerStatus.attributeTypeMap;
}
}
V1HorizontalPodAutoscalerStatus.discriminator = undefined;
V1HorizontalPodAutoscalerStatus.attributeTypeMap = [
{
"name": "currentCPUUtilizationPercentage",
"baseName": "currentCPUUtilizationPercentage",
"type": "number"
},
{
"name": "currentReplicas",
"baseName": "currentReplicas",
"type": "number"
},
{
"name": "desiredReplicas",
"baseName": "desiredReplicas",
"type": "number"
},
{
"name": "lastScaleTime",
"baseName": "lastScaleTime",
"type": "Date"
},
{
"name": "observedGeneration",
"baseName": "observedGeneration",
"type": "number"
}
];
exports.V1HorizontalPodAutoscalerStatus = V1HorizontalPodAutoscalerStatus;
/**
* HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.
*/
class V1HostAlias {
static getAttributeTypeMap() {
return V1HostAlias.attributeTypeMap;
}
}
V1HostAlias.discriminator = undefined;
V1HostAlias.attributeTypeMap = [
{
"name": "hostnames",
"baseName": "hostnames",
"type": "Array"
},
{
"name": "ip",
"baseName": "ip",
"type": "string"
}
];
exports.V1HostAlias = V1HostAlias;
/**
* Represents a host path mapped into a pod. Host path volumes do not support ownership management or SELinux relabeling.
*/
class V1HostPathVolumeSource {
static getAttributeTypeMap() {
return V1HostPathVolumeSource.attributeTypeMap;
}
}
V1HostPathVolumeSource.discriminator = undefined;
V1HostPathVolumeSource.attributeTypeMap = [
{
"name": "path",
"baseName": "path",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1HostPathVolumeSource = V1HostPathVolumeSource;
/**
* 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.
*/
class V1IPBlock {
static getAttributeTypeMap() {
return V1IPBlock.attributeTypeMap;
}
}
V1IPBlock.discriminator = undefined;
V1IPBlock.attributeTypeMap = [
{
"name": "cidr",
"baseName": "cidr",
"type": "string"
},
{
"name": "except",
"baseName": "except",
"type": "Array"
}
];
exports.V1IPBlock = V1IPBlock;
/**
* ISCSIPersistentVolumeSource represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.
*/
class V1ISCSIPersistentVolumeSource {
static getAttributeTypeMap() {
return V1ISCSIPersistentVolumeSource.attributeTypeMap;
}
}
V1ISCSIPersistentVolumeSource.discriminator = undefined;
V1ISCSIPersistentVolumeSource.attributeTypeMap = [
{
"name": "chapAuthDiscovery",
"baseName": "chapAuthDiscovery",
"type": "boolean"
},
{
"name": "chapAuthSession",
"baseName": "chapAuthSession",
"type": "boolean"
},
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "initiatorName",
"baseName": "initiatorName",
"type": "string"
},
{
"name": "iqn",
"baseName": "iqn",
"type": "string"
},
{
"name": "iscsiInterface",
"baseName": "iscsiInterface",
"type": "string"
},
{
"name": "lun",
"baseName": "lun",
"type": "number"
},
{
"name": "portals",
"baseName": "portals",
"type": "Array"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1SecretReference"
},
{
"name": "targetPortal",
"baseName": "targetPortal",
"type": "string"
}
];
exports.V1ISCSIPersistentVolumeSource = V1ISCSIPersistentVolumeSource;
/**
* Represents an ISCSI disk. ISCSI volumes can only be mounted as read/write once. ISCSI volumes support ownership management and SELinux relabeling.
*/
class V1ISCSIVolumeSource {
static getAttributeTypeMap() {
return V1ISCSIVolumeSource.attributeTypeMap;
}
}
V1ISCSIVolumeSource.discriminator = undefined;
V1ISCSIVolumeSource.attributeTypeMap = [
{
"name": "chapAuthDiscovery",
"baseName": "chapAuthDiscovery",
"type": "boolean"
},
{
"name": "chapAuthSession",
"baseName": "chapAuthSession",
"type": "boolean"
},
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "initiatorName",
"baseName": "initiatorName",
"type": "string"
},
{
"name": "iqn",
"baseName": "iqn",
"type": "string"
},
{
"name": "iscsiInterface",
"baseName": "iscsiInterface",
"type": "string"
},
{
"name": "lun",
"baseName": "lun",
"type": "number"
},
{
"name": "portals",
"baseName": "portals",
"type": "Array"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1LocalObjectReference"
},
{
"name": "targetPortal",
"baseName": "targetPortal",
"type": "string"
}
];
exports.V1ISCSIVolumeSource = V1ISCSIVolumeSource;
/**
* Initializer is information about an initializer that has not yet completed.
*/
class V1Initializer {
static getAttributeTypeMap() {
return V1Initializer.attributeTypeMap;
}
}
V1Initializer.discriminator = undefined;
V1Initializer.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
}
];
exports.V1Initializer = V1Initializer;
/**
* Initializers tracks the progress of initialization.
*/
class V1Initializers {
static getAttributeTypeMap() {
return V1Initializers.attributeTypeMap;
}
}
V1Initializers.discriminator = undefined;
V1Initializers.attributeTypeMap = [
{
"name": "pending",
"baseName": "pending",
"type": "Array"
},
{
"name": "result",
"baseName": "result",
"type": "V1Status"
}
];
exports.V1Initializers = V1Initializers;
/**
* Job represents the configuration of a single job.
*/
class V1Job {
static getAttributeTypeMap() {
return V1Job.attributeTypeMap;
}
}
V1Job.discriminator = undefined;
V1Job.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1JobSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1JobStatus"
}
];
exports.V1Job = V1Job;
/**
* JobCondition describes current state of a job.
*/
class V1JobCondition {
static getAttributeTypeMap() {
return V1JobCondition.attributeTypeMap;
}
}
V1JobCondition.discriminator = undefined;
V1JobCondition.attributeTypeMap = [
{
"name": "lastProbeTime",
"baseName": "lastProbeTime",
"type": "Date"
},
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1JobCondition = V1JobCondition;
/**
* JobList is a collection of jobs.
*/
class V1JobList {
static getAttributeTypeMap() {
return V1JobList.attributeTypeMap;
}
}
V1JobList.discriminator = undefined;
V1JobList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1JobList = V1JobList;
/**
* JobSpec describes how the job execution will look like.
*/
class V1JobSpec {
static getAttributeTypeMap() {
return V1JobSpec.attributeTypeMap;
}
}
V1JobSpec.discriminator = undefined;
V1JobSpec.attributeTypeMap = [
{
"name": "activeDeadlineSeconds",
"baseName": "activeDeadlineSeconds",
"type": "number"
},
{
"name": "backoffLimit",
"baseName": "backoffLimit",
"type": "number"
},
{
"name": "completions",
"baseName": "completions",
"type": "number"
},
{
"name": "manualSelector",
"baseName": "manualSelector",
"type": "boolean"
},
{
"name": "parallelism",
"baseName": "parallelism",
"type": "number"
},
{
"name": "selector",
"baseName": "selector",
"type": "V1LabelSelector"
},
{
"name": "template",
"baseName": "template",
"type": "V1PodTemplateSpec"
},
{
"name": "ttlSecondsAfterFinished",
"baseName": "ttlSecondsAfterFinished",
"type": "number"
}
];
exports.V1JobSpec = V1JobSpec;
/**
* JobStatus represents the current state of a Job.
*/
class V1JobStatus {
static getAttributeTypeMap() {
return V1JobStatus.attributeTypeMap;
}
}
V1JobStatus.discriminator = undefined;
V1JobStatus.attributeTypeMap = [
{
"name": "active",
"baseName": "active",
"type": "number"
},
{
"name": "completionTime",
"baseName": "completionTime",
"type": "Date"
},
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "failed",
"baseName": "failed",
"type": "number"
},
{
"name": "startTime",
"baseName": "startTime",
"type": "Date"
},
{
"name": "succeeded",
"baseName": "succeeded",
"type": "number"
}
];
exports.V1JobStatus = V1JobStatus;
/**
* Maps a string key to a path within a volume.
*/
class V1KeyToPath {
static getAttributeTypeMap() {
return V1KeyToPath.attributeTypeMap;
}
}
V1KeyToPath.discriminator = undefined;
V1KeyToPath.attributeTypeMap = [
{
"name": "key",
"baseName": "key",
"type": "string"
},
{
"name": "mode",
"baseName": "mode",
"type": "number"
},
{
"name": "path",
"baseName": "path",
"type": "string"
}
];
exports.V1KeyToPath = V1KeyToPath;
/**
* 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.
*/
class V1LabelSelector {
static getAttributeTypeMap() {
return V1LabelSelector.attributeTypeMap;
}
}
V1LabelSelector.discriminator = undefined;
V1LabelSelector.attributeTypeMap = [
{
"name": "matchExpressions",
"baseName": "matchExpressions",
"type": "Array"
},
{
"name": "matchLabels",
"baseName": "matchLabels",
"type": "{ [key: string]: string; }"
}
];
exports.V1LabelSelector = V1LabelSelector;
/**
* A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
*/
class V1LabelSelectorRequirement {
static getAttributeTypeMap() {
return V1LabelSelectorRequirement.attributeTypeMap;
}
}
V1LabelSelectorRequirement.discriminator = undefined;
V1LabelSelectorRequirement.attributeTypeMap = [
{
"name": "key",
"baseName": "key",
"type": "string"
},
{
"name": "operator",
"baseName": "operator",
"type": "string"
},
{
"name": "values",
"baseName": "values",
"type": "Array"
}
];
exports.V1LabelSelectorRequirement = V1LabelSelectorRequirement;
/**
* 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.
*/
class V1Lifecycle {
static getAttributeTypeMap() {
return V1Lifecycle.attributeTypeMap;
}
}
V1Lifecycle.discriminator = undefined;
V1Lifecycle.attributeTypeMap = [
{
"name": "postStart",
"baseName": "postStart",
"type": "V1Handler"
},
{
"name": "preStop",
"baseName": "preStop",
"type": "V1Handler"
}
];
exports.V1Lifecycle = V1Lifecycle;
/**
* LimitRange sets resource usage limits for each kind of resource in a Namespace.
*/
class V1LimitRange {
static getAttributeTypeMap() {
return V1LimitRange.attributeTypeMap;
}
}
V1LimitRange.discriminator = undefined;
V1LimitRange.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1LimitRangeSpec"
}
];
exports.V1LimitRange = V1LimitRange;
/**
* LimitRangeItem defines a min/max usage limit for any resource that matches on kind.
*/
class V1LimitRangeItem {
static getAttributeTypeMap() {
return V1LimitRangeItem.attributeTypeMap;
}
}
V1LimitRangeItem.discriminator = undefined;
V1LimitRangeItem.attributeTypeMap = [
{
"name": "_default",
"baseName": "default",
"type": "{ [key: string]: string; }"
},
{
"name": "defaultRequest",
"baseName": "defaultRequest",
"type": "{ [key: string]: string; }"
},
{
"name": "max",
"baseName": "max",
"type": "{ [key: string]: string; }"
},
{
"name": "maxLimitRequestRatio",
"baseName": "maxLimitRequestRatio",
"type": "{ [key: string]: string; }"
},
{
"name": "min",
"baseName": "min",
"type": "{ [key: string]: string; }"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1LimitRangeItem = V1LimitRangeItem;
/**
* LimitRangeList is a list of LimitRange items.
*/
class V1LimitRangeList {
static getAttributeTypeMap() {
return V1LimitRangeList.attributeTypeMap;
}
}
V1LimitRangeList.discriminator = undefined;
V1LimitRangeList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1LimitRangeList = V1LimitRangeList;
/**
* LimitRangeSpec defines a min/max usage limit for resources that match on kind.
*/
class V1LimitRangeSpec {
static getAttributeTypeMap() {
return V1LimitRangeSpec.attributeTypeMap;
}
}
V1LimitRangeSpec.discriminator = undefined;
V1LimitRangeSpec.attributeTypeMap = [
{
"name": "limits",
"baseName": "limits",
"type": "Array"
}
];
exports.V1LimitRangeSpec = V1LimitRangeSpec;
/**
* ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.
*/
class V1ListMeta {
static getAttributeTypeMap() {
return V1ListMeta.attributeTypeMap;
}
}
V1ListMeta.discriminator = undefined;
V1ListMeta.attributeTypeMap = [
{
"name": "_continue",
"baseName": "continue",
"type": "string"
},
{
"name": "resourceVersion",
"baseName": "resourceVersion",
"type": "string"
},
{
"name": "selfLink",
"baseName": "selfLink",
"type": "string"
}
];
exports.V1ListMeta = V1ListMeta;
/**
* LoadBalancerIngress represents the status of a load-balancer ingress point: traffic intended for the service should be sent to an ingress point.
*/
class V1LoadBalancerIngress {
static getAttributeTypeMap() {
return V1LoadBalancerIngress.attributeTypeMap;
}
}
V1LoadBalancerIngress.discriminator = undefined;
V1LoadBalancerIngress.attributeTypeMap = [
{
"name": "hostname",
"baseName": "hostname",
"type": "string"
},
{
"name": "ip",
"baseName": "ip",
"type": "string"
}
];
exports.V1LoadBalancerIngress = V1LoadBalancerIngress;
/**
* LoadBalancerStatus represents the status of a load-balancer.
*/
class V1LoadBalancerStatus {
static getAttributeTypeMap() {
return V1LoadBalancerStatus.attributeTypeMap;
}
}
V1LoadBalancerStatus.discriminator = undefined;
V1LoadBalancerStatus.attributeTypeMap = [
{
"name": "ingress",
"baseName": "ingress",
"type": "Array"
}
];
exports.V1LoadBalancerStatus = V1LoadBalancerStatus;
/**
* LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.
*/
class V1LocalObjectReference {
static getAttributeTypeMap() {
return V1LocalObjectReference.attributeTypeMap;
}
}
V1LocalObjectReference.discriminator = undefined;
V1LocalObjectReference.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
}
];
exports.V1LocalObjectReference = V1LocalObjectReference;
/**
* 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.
*/
class V1LocalSubjectAccessReview {
static getAttributeTypeMap() {
return V1LocalSubjectAccessReview.attributeTypeMap;
}
}
V1LocalSubjectAccessReview.discriminator = undefined;
V1LocalSubjectAccessReview.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1SubjectAccessReviewSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1SubjectAccessReviewStatus"
}
];
exports.V1LocalSubjectAccessReview = V1LocalSubjectAccessReview;
/**
* Local represents directly-attached storage with node affinity (Beta feature)
*/
class V1LocalVolumeSource {
static getAttributeTypeMap() {
return V1LocalVolumeSource.attributeTypeMap;
}
}
V1LocalVolumeSource.discriminator = undefined;
V1LocalVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "path",
"baseName": "path",
"type": "string"
}
];
exports.V1LocalVolumeSource = V1LocalVolumeSource;
/**
* Represents an NFS mount that lasts the lifetime of a pod. NFS volumes do not support ownership management or SELinux relabeling.
*/
class V1NFSVolumeSource {
static getAttributeTypeMap() {
return V1NFSVolumeSource.attributeTypeMap;
}
}
V1NFSVolumeSource.discriminator = undefined;
V1NFSVolumeSource.attributeTypeMap = [
{
"name": "path",
"baseName": "path",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "server",
"baseName": "server",
"type": "string"
}
];
exports.V1NFSVolumeSource = V1NFSVolumeSource;
/**
* Namespace provides a scope for Names. Use of multiple namespaces is optional.
*/
class V1Namespace {
static getAttributeTypeMap() {
return V1Namespace.attributeTypeMap;
}
}
V1Namespace.discriminator = undefined;
V1Namespace.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1NamespaceSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1NamespaceStatus"
}
];
exports.V1Namespace = V1Namespace;
/**
* NamespaceList is a list of Namespaces.
*/
class V1NamespaceList {
static getAttributeTypeMap() {
return V1NamespaceList.attributeTypeMap;
}
}
V1NamespaceList.discriminator = undefined;
V1NamespaceList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1NamespaceList = V1NamespaceList;
/**
* NamespaceSpec describes the attributes on a Namespace.
*/
class V1NamespaceSpec {
static getAttributeTypeMap() {
return V1NamespaceSpec.attributeTypeMap;
}
}
V1NamespaceSpec.discriminator = undefined;
V1NamespaceSpec.attributeTypeMap = [
{
"name": "finalizers",
"baseName": "finalizers",
"type": "Array"
}
];
exports.V1NamespaceSpec = V1NamespaceSpec;
/**
* NamespaceStatus is information about the current status of a Namespace.
*/
class V1NamespaceStatus {
static getAttributeTypeMap() {
return V1NamespaceStatus.attributeTypeMap;
}
}
V1NamespaceStatus.discriminator = undefined;
V1NamespaceStatus.attributeTypeMap = [
{
"name": "phase",
"baseName": "phase",
"type": "string"
}
];
exports.V1NamespaceStatus = V1NamespaceStatus;
/**
* NetworkPolicy describes what network traffic is allowed for a set of Pods
*/
class V1NetworkPolicy {
static getAttributeTypeMap() {
return V1NetworkPolicy.attributeTypeMap;
}
}
V1NetworkPolicy.discriminator = undefined;
V1NetworkPolicy.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1NetworkPolicySpec"
}
];
exports.V1NetworkPolicy = V1NetworkPolicy;
/**
* 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
*/
class V1NetworkPolicyEgressRule {
static getAttributeTypeMap() {
return V1NetworkPolicyEgressRule.attributeTypeMap;
}
}
V1NetworkPolicyEgressRule.discriminator = undefined;
V1NetworkPolicyEgressRule.attributeTypeMap = [
{
"name": "ports",
"baseName": "ports",
"type": "Array"
},
{
"name": "to",
"baseName": "to",
"type": "Array"
}
];
exports.V1NetworkPolicyEgressRule = V1NetworkPolicyEgressRule;
/**
* 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.
*/
class V1NetworkPolicyIngressRule {
static getAttributeTypeMap() {
return V1NetworkPolicyIngressRule.attributeTypeMap;
}
}
V1NetworkPolicyIngressRule.discriminator = undefined;
V1NetworkPolicyIngressRule.attributeTypeMap = [
{
"name": "from",
"baseName": "from",
"type": "Array"
},
{
"name": "ports",
"baseName": "ports",
"type": "Array"
}
];
exports.V1NetworkPolicyIngressRule = V1NetworkPolicyIngressRule;
/**
* NetworkPolicyList is a list of NetworkPolicy objects.
*/
class V1NetworkPolicyList {
static getAttributeTypeMap() {
return V1NetworkPolicyList.attributeTypeMap;
}
}
V1NetworkPolicyList.discriminator = undefined;
V1NetworkPolicyList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1NetworkPolicyList = V1NetworkPolicyList;
/**
* NetworkPolicyPeer describes a peer to allow traffic from. Only certain combinations of fields are allowed
*/
class V1NetworkPolicyPeer {
static getAttributeTypeMap() {
return V1NetworkPolicyPeer.attributeTypeMap;
}
}
V1NetworkPolicyPeer.discriminator = undefined;
V1NetworkPolicyPeer.attributeTypeMap = [
{
"name": "ipBlock",
"baseName": "ipBlock",
"type": "V1IPBlock"
},
{
"name": "namespaceSelector",
"baseName": "namespaceSelector",
"type": "V1LabelSelector"
},
{
"name": "podSelector",
"baseName": "podSelector",
"type": "V1LabelSelector"
}
];
exports.V1NetworkPolicyPeer = V1NetworkPolicyPeer;
/**
* NetworkPolicyPort describes a port to allow traffic on
*/
class V1NetworkPolicyPort {
static getAttributeTypeMap() {
return V1NetworkPolicyPort.attributeTypeMap;
}
}
V1NetworkPolicyPort.discriminator = undefined;
V1NetworkPolicyPort.attributeTypeMap = [
{
"name": "port",
"baseName": "port",
"type": "any"
},
{
"name": "protocol",
"baseName": "protocol",
"type": "string"
}
];
exports.V1NetworkPolicyPort = V1NetworkPolicyPort;
/**
* NetworkPolicySpec provides the specification of a NetworkPolicy
*/
class V1NetworkPolicySpec {
static getAttributeTypeMap() {
return V1NetworkPolicySpec.attributeTypeMap;
}
}
V1NetworkPolicySpec.discriminator = undefined;
V1NetworkPolicySpec.attributeTypeMap = [
{
"name": "egress",
"baseName": "egress",
"type": "Array"
},
{
"name": "ingress",
"baseName": "ingress",
"type": "Array"
},
{
"name": "podSelector",
"baseName": "podSelector",
"type": "V1LabelSelector"
},
{
"name": "policyTypes",
"baseName": "policyTypes",
"type": "Array"
}
];
exports.V1NetworkPolicySpec = V1NetworkPolicySpec;
/**
* Node is a worker node in Kubernetes. Each node will have a unique identifier in the cache (i.e. in etcd).
*/
class V1Node {
static getAttributeTypeMap() {
return V1Node.attributeTypeMap;
}
}
V1Node.discriminator = undefined;
V1Node.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1NodeSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1NodeStatus"
}
];
exports.V1Node = V1Node;
/**
* NodeAddress contains information for the node's address.
*/
class V1NodeAddress {
static getAttributeTypeMap() {
return V1NodeAddress.attributeTypeMap;
}
}
V1NodeAddress.discriminator = undefined;
V1NodeAddress.attributeTypeMap = [
{
"name": "address",
"baseName": "address",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1NodeAddress = V1NodeAddress;
/**
* Node affinity is a group of node affinity scheduling rules.
*/
class V1NodeAffinity {
static getAttributeTypeMap() {
return V1NodeAffinity.attributeTypeMap;
}
}
V1NodeAffinity.discriminator = undefined;
V1NodeAffinity.attributeTypeMap = [
{
"name": "preferredDuringSchedulingIgnoredDuringExecution",
"baseName": "preferredDuringSchedulingIgnoredDuringExecution",
"type": "Array"
},
{
"name": "requiredDuringSchedulingIgnoredDuringExecution",
"baseName": "requiredDuringSchedulingIgnoredDuringExecution",
"type": "V1NodeSelector"
}
];
exports.V1NodeAffinity = V1NodeAffinity;
/**
* NodeCondition contains condition information for a node.
*/
class V1NodeCondition {
static getAttributeTypeMap() {
return V1NodeCondition.attributeTypeMap;
}
}
V1NodeCondition.discriminator = undefined;
V1NodeCondition.attributeTypeMap = [
{
"name": "lastHeartbeatTime",
"baseName": "lastHeartbeatTime",
"type": "Date"
},
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1NodeCondition = V1NodeCondition;
/**
* NodeConfigSource specifies a source of node configuration. Exactly one subfield (excluding metadata) must be non-nil.
*/
class V1NodeConfigSource {
static getAttributeTypeMap() {
return V1NodeConfigSource.attributeTypeMap;
}
}
V1NodeConfigSource.discriminator = undefined;
V1NodeConfigSource.attributeTypeMap = [
{
"name": "configMap",
"baseName": "configMap",
"type": "V1ConfigMapNodeConfigSource"
}
];
exports.V1NodeConfigSource = V1NodeConfigSource;
/**
* NodeConfigStatus describes the status of the config assigned by Node.Spec.ConfigSource.
*/
class V1NodeConfigStatus {
static getAttributeTypeMap() {
return V1NodeConfigStatus.attributeTypeMap;
}
}
V1NodeConfigStatus.discriminator = undefined;
V1NodeConfigStatus.attributeTypeMap = [
{
"name": "active",
"baseName": "active",
"type": "V1NodeConfigSource"
},
{
"name": "assigned",
"baseName": "assigned",
"type": "V1NodeConfigSource"
},
{
"name": "error",
"baseName": "error",
"type": "string"
},
{
"name": "lastKnownGood",
"baseName": "lastKnownGood",
"type": "V1NodeConfigSource"
}
];
exports.V1NodeConfigStatus = V1NodeConfigStatus;
/**
* NodeDaemonEndpoints lists ports opened by daemons running on the Node.
*/
class V1NodeDaemonEndpoints {
static getAttributeTypeMap() {
return V1NodeDaemonEndpoints.attributeTypeMap;
}
}
V1NodeDaemonEndpoints.discriminator = undefined;
V1NodeDaemonEndpoints.attributeTypeMap = [
{
"name": "kubeletEndpoint",
"baseName": "kubeletEndpoint",
"type": "V1DaemonEndpoint"
}
];
exports.V1NodeDaemonEndpoints = V1NodeDaemonEndpoints;
/**
* NodeList is the whole list of all Nodes which have been registered with master.
*/
class V1NodeList {
static getAttributeTypeMap() {
return V1NodeList.attributeTypeMap;
}
}
V1NodeList.discriminator = undefined;
V1NodeList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1NodeList = V1NodeList;
/**
* 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.
*/
class V1NodeSelector {
static getAttributeTypeMap() {
return V1NodeSelector.attributeTypeMap;
}
}
V1NodeSelector.discriminator = undefined;
V1NodeSelector.attributeTypeMap = [
{
"name": "nodeSelectorTerms",
"baseName": "nodeSelectorTerms",
"type": "Array"
}
];
exports.V1NodeSelector = V1NodeSelector;
/**
* A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
*/
class V1NodeSelectorRequirement {
static getAttributeTypeMap() {
return V1NodeSelectorRequirement.attributeTypeMap;
}
}
V1NodeSelectorRequirement.discriminator = undefined;
V1NodeSelectorRequirement.attributeTypeMap = [
{
"name": "key",
"baseName": "key",
"type": "string"
},
{
"name": "operator",
"baseName": "operator",
"type": "string"
},
{
"name": "values",
"baseName": "values",
"type": "Array"
}
];
exports.V1NodeSelectorRequirement = 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.
*/
class V1NodeSelectorTerm {
static getAttributeTypeMap() {
return V1NodeSelectorTerm.attributeTypeMap;
}
}
V1NodeSelectorTerm.discriminator = undefined;
V1NodeSelectorTerm.attributeTypeMap = [
{
"name": "matchExpressions",
"baseName": "matchExpressions",
"type": "Array"
},
{
"name": "matchFields",
"baseName": "matchFields",
"type": "Array"
}
];
exports.V1NodeSelectorTerm = V1NodeSelectorTerm;
/**
* NodeSpec describes the attributes that a node is created with.
*/
class V1NodeSpec {
static getAttributeTypeMap() {
return V1NodeSpec.attributeTypeMap;
}
}
V1NodeSpec.discriminator = undefined;
V1NodeSpec.attributeTypeMap = [
{
"name": "configSource",
"baseName": "configSource",
"type": "V1NodeConfigSource"
},
{
"name": "externalID",
"baseName": "externalID",
"type": "string"
},
{
"name": "podCIDR",
"baseName": "podCIDR",
"type": "string"
},
{
"name": "providerID",
"baseName": "providerID",
"type": "string"
},
{
"name": "taints",
"baseName": "taints",
"type": "Array"
},
{
"name": "unschedulable",
"baseName": "unschedulable",
"type": "boolean"
}
];
exports.V1NodeSpec = V1NodeSpec;
/**
* NodeStatus is information about the current status of a node.
*/
class V1NodeStatus {
static getAttributeTypeMap() {
return V1NodeStatus.attributeTypeMap;
}
}
V1NodeStatus.discriminator = undefined;
V1NodeStatus.attributeTypeMap = [
{
"name": "addresses",
"baseName": "addresses",
"type": "Array"
},
{
"name": "allocatable",
"baseName": "allocatable",
"type": "{ [key: string]: string; }"
},
{
"name": "capacity",
"baseName": "capacity",
"type": "{ [key: string]: string; }"
},
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "config",
"baseName": "config",
"type": "V1NodeConfigStatus"
},
{
"name": "daemonEndpoints",
"baseName": "daemonEndpoints",
"type": "V1NodeDaemonEndpoints"
},
{
"name": "images",
"baseName": "images",
"type": "Array"
},
{
"name": "nodeInfo",
"baseName": "nodeInfo",
"type": "V1NodeSystemInfo"
},
{
"name": "phase",
"baseName": "phase",
"type": "string"
},
{
"name": "volumesAttached",
"baseName": "volumesAttached",
"type": "Array"
},
{
"name": "volumesInUse",
"baseName": "volumesInUse",
"type": "Array"
}
];
exports.V1NodeStatus = V1NodeStatus;
/**
* NodeSystemInfo is a set of ids/uuids to uniquely identify the node.
*/
class V1NodeSystemInfo {
static getAttributeTypeMap() {
return V1NodeSystemInfo.attributeTypeMap;
}
}
V1NodeSystemInfo.discriminator = undefined;
V1NodeSystemInfo.attributeTypeMap = [
{
"name": "architecture",
"baseName": "architecture",
"type": "string"
},
{
"name": "bootID",
"baseName": "bootID",
"type": "string"
},
{
"name": "containerRuntimeVersion",
"baseName": "containerRuntimeVersion",
"type": "string"
},
{
"name": "kernelVersion",
"baseName": "kernelVersion",
"type": "string"
},
{
"name": "kubeProxyVersion",
"baseName": "kubeProxyVersion",
"type": "string"
},
{
"name": "kubeletVersion",
"baseName": "kubeletVersion",
"type": "string"
},
{
"name": "machineID",
"baseName": "machineID",
"type": "string"
},
{
"name": "operatingSystem",
"baseName": "operatingSystem",
"type": "string"
},
{
"name": "osImage",
"baseName": "osImage",
"type": "string"
},
{
"name": "systemUUID",
"baseName": "systemUUID",
"type": "string"
}
];
exports.V1NodeSystemInfo = V1NodeSystemInfo;
/**
* NonResourceAttributes includes the authorization attributes available for non-resource requests to the Authorizer interface
*/
class V1NonResourceAttributes {
static getAttributeTypeMap() {
return V1NonResourceAttributes.attributeTypeMap;
}
}
V1NonResourceAttributes.discriminator = undefined;
V1NonResourceAttributes.attributeTypeMap = [
{
"name": "path",
"baseName": "path",
"type": "string"
},
{
"name": "verb",
"baseName": "verb",
"type": "string"
}
];
exports.V1NonResourceAttributes = V1NonResourceAttributes;
/**
* NonResourceRule holds information that describes a rule for the non-resource
*/
class V1NonResourceRule {
static getAttributeTypeMap() {
return V1NonResourceRule.attributeTypeMap;
}
}
V1NonResourceRule.discriminator = undefined;
V1NonResourceRule.attributeTypeMap = [
{
"name": "nonResourceURLs",
"baseName": "nonResourceURLs",
"type": "Array"
},
{
"name": "verbs",
"baseName": "verbs",
"type": "Array"
}
];
exports.V1NonResourceRule = V1NonResourceRule;
/**
* ObjectFieldSelector selects an APIVersioned field of an object.
*/
class V1ObjectFieldSelector {
static getAttributeTypeMap() {
return V1ObjectFieldSelector.attributeTypeMap;
}
}
V1ObjectFieldSelector.discriminator = undefined;
V1ObjectFieldSelector.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "fieldPath",
"baseName": "fieldPath",
"type": "string"
}
];
exports.V1ObjectFieldSelector = V1ObjectFieldSelector;
/**
* ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.
*/
class V1ObjectMeta {
static getAttributeTypeMap() {
return V1ObjectMeta.attributeTypeMap;
}
}
V1ObjectMeta.discriminator = undefined;
V1ObjectMeta.attributeTypeMap = [
{
"name": "annotations",
"baseName": "annotations",
"type": "{ [key: string]: string; }"
},
{
"name": "clusterName",
"baseName": "clusterName",
"type": "string"
},
{
"name": "creationTimestamp",
"baseName": "creationTimestamp",
"type": "Date"
},
{
"name": "deletionGracePeriodSeconds",
"baseName": "deletionGracePeriodSeconds",
"type": "number"
},
{
"name": "deletionTimestamp",
"baseName": "deletionTimestamp",
"type": "Date"
},
{
"name": "finalizers",
"baseName": "finalizers",
"type": "Array"
},
{
"name": "generateName",
"baseName": "generateName",
"type": "string"
},
{
"name": "generation",
"baseName": "generation",
"type": "number"
},
{
"name": "initializers",
"baseName": "initializers",
"type": "V1Initializers"
},
{
"name": "labels",
"baseName": "labels",
"type": "{ [key: string]: string; }"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
},
{
"name": "ownerReferences",
"baseName": "ownerReferences",
"type": "Array"
},
{
"name": "resourceVersion",
"baseName": "resourceVersion",
"type": "string"
},
{
"name": "selfLink",
"baseName": "selfLink",
"type": "string"
},
{
"name": "uid",
"baseName": "uid",
"type": "string"
}
];
exports.V1ObjectMeta = V1ObjectMeta;
/**
* ObjectReference contains enough information to let you inspect or modify the referred object.
*/
class V1ObjectReference {
static getAttributeTypeMap() {
return V1ObjectReference.attributeTypeMap;
}
}
V1ObjectReference.discriminator = undefined;
V1ObjectReference.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "fieldPath",
"baseName": "fieldPath",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
},
{
"name": "resourceVersion",
"baseName": "resourceVersion",
"type": "string"
},
{
"name": "uid",
"baseName": "uid",
"type": "string"
}
];
exports.V1ObjectReference = V1ObjectReference;
/**
* 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.
*/
class V1OwnerReference {
static getAttributeTypeMap() {
return V1OwnerReference.attributeTypeMap;
}
}
V1OwnerReference.discriminator = undefined;
V1OwnerReference.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "blockOwnerDeletion",
"baseName": "blockOwnerDeletion",
"type": "boolean"
},
{
"name": "controller",
"baseName": "controller",
"type": "boolean"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "uid",
"baseName": "uid",
"type": "string"
}
];
exports.V1OwnerReference = V1OwnerReference;
/**
* 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
*/
class V1PersistentVolume {
static getAttributeTypeMap() {
return V1PersistentVolume.attributeTypeMap;
}
}
V1PersistentVolume.discriminator = undefined;
V1PersistentVolume.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1PersistentVolumeSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1PersistentVolumeStatus"
}
];
exports.V1PersistentVolume = V1PersistentVolume;
/**
* PersistentVolumeClaim is a user's request for and claim to a persistent volume
*/
class V1PersistentVolumeClaim {
static getAttributeTypeMap() {
return V1PersistentVolumeClaim.attributeTypeMap;
}
}
V1PersistentVolumeClaim.discriminator = undefined;
V1PersistentVolumeClaim.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1PersistentVolumeClaimSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1PersistentVolumeClaimStatus"
}
];
exports.V1PersistentVolumeClaim = V1PersistentVolumeClaim;
/**
* PersistentVolumeClaimCondition contails details about state of pvc
*/
class V1PersistentVolumeClaimCondition {
static getAttributeTypeMap() {
return V1PersistentVolumeClaimCondition.attributeTypeMap;
}
}
V1PersistentVolumeClaimCondition.discriminator = undefined;
V1PersistentVolumeClaimCondition.attributeTypeMap = [
{
"name": "lastProbeTime",
"baseName": "lastProbeTime",
"type": "Date"
},
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1PersistentVolumeClaimCondition = V1PersistentVolumeClaimCondition;
/**
* PersistentVolumeClaimList is a list of PersistentVolumeClaim items.
*/
class V1PersistentVolumeClaimList {
static getAttributeTypeMap() {
return V1PersistentVolumeClaimList.attributeTypeMap;
}
}
V1PersistentVolumeClaimList.discriminator = undefined;
V1PersistentVolumeClaimList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1PersistentVolumeClaimList = V1PersistentVolumeClaimList;
/**
* PersistentVolumeClaimSpec describes the common attributes of storage devices and allows a Source for provider-specific attributes
*/
class V1PersistentVolumeClaimSpec {
static getAttributeTypeMap() {
return V1PersistentVolumeClaimSpec.attributeTypeMap;
}
}
V1PersistentVolumeClaimSpec.discriminator = undefined;
V1PersistentVolumeClaimSpec.attributeTypeMap = [
{
"name": "accessModes",
"baseName": "accessModes",
"type": "Array"
},
{
"name": "dataSource",
"baseName": "dataSource",
"type": "V1TypedLocalObjectReference"
},
{
"name": "resources",
"baseName": "resources",
"type": "V1ResourceRequirements"
},
{
"name": "selector",
"baseName": "selector",
"type": "V1LabelSelector"
},
{
"name": "storageClassName",
"baseName": "storageClassName",
"type": "string"
},
{
"name": "volumeMode",
"baseName": "volumeMode",
"type": "string"
},
{
"name": "volumeName",
"baseName": "volumeName",
"type": "string"
}
];
exports.V1PersistentVolumeClaimSpec = V1PersistentVolumeClaimSpec;
/**
* PersistentVolumeClaimStatus is the current status of a persistent volume claim.
*/
class V1PersistentVolumeClaimStatus {
static getAttributeTypeMap() {
return V1PersistentVolumeClaimStatus.attributeTypeMap;
}
}
V1PersistentVolumeClaimStatus.discriminator = undefined;
V1PersistentVolumeClaimStatus.attributeTypeMap = [
{
"name": "accessModes",
"baseName": "accessModes",
"type": "Array"
},
{
"name": "capacity",
"baseName": "capacity",
"type": "{ [key: string]: string; }"
},
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "phase",
"baseName": "phase",
"type": "string"
}
];
exports.V1PersistentVolumeClaimStatus = V1PersistentVolumeClaimStatus;
/**
* 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).
*/
class V1PersistentVolumeClaimVolumeSource {
static getAttributeTypeMap() {
return V1PersistentVolumeClaimVolumeSource.attributeTypeMap;
}
}
V1PersistentVolumeClaimVolumeSource.discriminator = undefined;
V1PersistentVolumeClaimVolumeSource.attributeTypeMap = [
{
"name": "claimName",
"baseName": "claimName",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
}
];
exports.V1PersistentVolumeClaimVolumeSource = V1PersistentVolumeClaimVolumeSource;
/**
* PersistentVolumeList is a list of PersistentVolume items.
*/
class V1PersistentVolumeList {
static getAttributeTypeMap() {
return V1PersistentVolumeList.attributeTypeMap;
}
}
V1PersistentVolumeList.discriminator = undefined;
V1PersistentVolumeList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1PersistentVolumeList = V1PersistentVolumeList;
/**
* PersistentVolumeSpec is the specification of a persistent volume.
*/
class V1PersistentVolumeSpec {
static getAttributeTypeMap() {
return V1PersistentVolumeSpec.attributeTypeMap;
}
}
V1PersistentVolumeSpec.discriminator = undefined;
V1PersistentVolumeSpec.attributeTypeMap = [
{
"name": "accessModes",
"baseName": "accessModes",
"type": "Array"
},
{
"name": "awsElasticBlockStore",
"baseName": "awsElasticBlockStore",
"type": "V1AWSElasticBlockStoreVolumeSource"
},
{
"name": "azureDisk",
"baseName": "azureDisk",
"type": "V1AzureDiskVolumeSource"
},
{
"name": "azureFile",
"baseName": "azureFile",
"type": "V1AzureFilePersistentVolumeSource"
},
{
"name": "capacity",
"baseName": "capacity",
"type": "{ [key: string]: string; }"
},
{
"name": "cephfs",
"baseName": "cephfs",
"type": "V1CephFSPersistentVolumeSource"
},
{
"name": "cinder",
"baseName": "cinder",
"type": "V1CinderPersistentVolumeSource"
},
{
"name": "claimRef",
"baseName": "claimRef",
"type": "V1ObjectReference"
},
{
"name": "csi",
"baseName": "csi",
"type": "V1CSIPersistentVolumeSource"
},
{
"name": "fc",
"baseName": "fc",
"type": "V1FCVolumeSource"
},
{
"name": "flexVolume",
"baseName": "flexVolume",
"type": "V1FlexPersistentVolumeSource"
},
{
"name": "flocker",
"baseName": "flocker",
"type": "V1FlockerVolumeSource"
},
{
"name": "gcePersistentDisk",
"baseName": "gcePersistentDisk",
"type": "V1GCEPersistentDiskVolumeSource"
},
{
"name": "glusterfs",
"baseName": "glusterfs",
"type": "V1GlusterfsPersistentVolumeSource"
},
{
"name": "hostPath",
"baseName": "hostPath",
"type": "V1HostPathVolumeSource"
},
{
"name": "iscsi",
"baseName": "iscsi",
"type": "V1ISCSIPersistentVolumeSource"
},
{
"name": "local",
"baseName": "local",
"type": "V1LocalVolumeSource"
},
{
"name": "mountOptions",
"baseName": "mountOptions",
"type": "Array"
},
{
"name": "nfs",
"baseName": "nfs",
"type": "V1NFSVolumeSource"
},
{
"name": "nodeAffinity",
"baseName": "nodeAffinity",
"type": "V1VolumeNodeAffinity"
},
{
"name": "persistentVolumeReclaimPolicy",
"baseName": "persistentVolumeReclaimPolicy",
"type": "string"
},
{
"name": "photonPersistentDisk",
"baseName": "photonPersistentDisk",
"type": "V1PhotonPersistentDiskVolumeSource"
},
{
"name": "portworxVolume",
"baseName": "portworxVolume",
"type": "V1PortworxVolumeSource"
},
{
"name": "quobyte",
"baseName": "quobyte",
"type": "V1QuobyteVolumeSource"
},
{
"name": "rbd",
"baseName": "rbd",
"type": "V1RBDPersistentVolumeSource"
},
{
"name": "scaleIO",
"baseName": "scaleIO",
"type": "V1ScaleIOPersistentVolumeSource"
},
{
"name": "storageClassName",
"baseName": "storageClassName",
"type": "string"
},
{
"name": "storageos",
"baseName": "storageos",
"type": "V1StorageOSPersistentVolumeSource"
},
{
"name": "volumeMode",
"baseName": "volumeMode",
"type": "string"
},
{
"name": "vsphereVolume",
"baseName": "vsphereVolume",
"type": "V1VsphereVirtualDiskVolumeSource"
}
];
exports.V1PersistentVolumeSpec = V1PersistentVolumeSpec;
/**
* PersistentVolumeStatus is the current status of a persistent volume.
*/
class V1PersistentVolumeStatus {
static getAttributeTypeMap() {
return V1PersistentVolumeStatus.attributeTypeMap;
}
}
V1PersistentVolumeStatus.discriminator = undefined;
V1PersistentVolumeStatus.attributeTypeMap = [
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "phase",
"baseName": "phase",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
}
];
exports.V1PersistentVolumeStatus = V1PersistentVolumeStatus;
/**
* Represents a Photon Controller persistent disk resource.
*/
class V1PhotonPersistentDiskVolumeSource {
static getAttributeTypeMap() {
return V1PhotonPersistentDiskVolumeSource.attributeTypeMap;
}
}
V1PhotonPersistentDiskVolumeSource.discriminator = undefined;
V1PhotonPersistentDiskVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "pdID",
"baseName": "pdID",
"type": "string"
}
];
exports.V1PhotonPersistentDiskVolumeSource = V1PhotonPersistentDiskVolumeSource;
/**
* Pod is a collection of containers that can run on a host. This resource is created by clients and scheduled onto hosts.
*/
class V1Pod {
static getAttributeTypeMap() {
return V1Pod.attributeTypeMap;
}
}
V1Pod.discriminator = undefined;
V1Pod.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1PodSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1PodStatus"
}
];
exports.V1Pod = V1Pod;
/**
* Pod affinity is a group of inter pod affinity scheduling rules.
*/
class V1PodAffinity {
static getAttributeTypeMap() {
return V1PodAffinity.attributeTypeMap;
}
}
V1PodAffinity.discriminator = undefined;
V1PodAffinity.attributeTypeMap = [
{
"name": "preferredDuringSchedulingIgnoredDuringExecution",
"baseName": "preferredDuringSchedulingIgnoredDuringExecution",
"type": "Array"
},
{
"name": "requiredDuringSchedulingIgnoredDuringExecution",
"baseName": "requiredDuringSchedulingIgnoredDuringExecution",
"type": "Array"
}
];
exports.V1PodAffinity = V1PodAffinity;
/**
* 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
*/
class V1PodAffinityTerm {
static getAttributeTypeMap() {
return V1PodAffinityTerm.attributeTypeMap;
}
}
V1PodAffinityTerm.discriminator = undefined;
V1PodAffinityTerm.attributeTypeMap = [
{
"name": "labelSelector",
"baseName": "labelSelector",
"type": "V1LabelSelector"
},
{
"name": "namespaces",
"baseName": "namespaces",
"type": "Array"
},
{
"name": "topologyKey",
"baseName": "topologyKey",
"type": "string"
}
];
exports.V1PodAffinityTerm = V1PodAffinityTerm;
/**
* Pod anti affinity is a group of inter pod anti affinity scheduling rules.
*/
class V1PodAntiAffinity {
static getAttributeTypeMap() {
return V1PodAntiAffinity.attributeTypeMap;
}
}
V1PodAntiAffinity.discriminator = undefined;
V1PodAntiAffinity.attributeTypeMap = [
{
"name": "preferredDuringSchedulingIgnoredDuringExecution",
"baseName": "preferredDuringSchedulingIgnoredDuringExecution",
"type": "Array"
},
{
"name": "requiredDuringSchedulingIgnoredDuringExecution",
"baseName": "requiredDuringSchedulingIgnoredDuringExecution",
"type": "Array"
}
];
exports.V1PodAntiAffinity = V1PodAntiAffinity;
/**
* PodCondition contains details for the current condition of this pod.
*/
class V1PodCondition {
static getAttributeTypeMap() {
return V1PodCondition.attributeTypeMap;
}
}
V1PodCondition.discriminator = undefined;
V1PodCondition.attributeTypeMap = [
{
"name": "lastProbeTime",
"baseName": "lastProbeTime",
"type": "Date"
},
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1PodCondition = V1PodCondition;
/**
* PodDNSConfig defines the DNS parameters of a pod in addition to those generated from DNSPolicy.
*/
class V1PodDNSConfig {
static getAttributeTypeMap() {
return V1PodDNSConfig.attributeTypeMap;
}
}
V1PodDNSConfig.discriminator = undefined;
V1PodDNSConfig.attributeTypeMap = [
{
"name": "nameservers",
"baseName": "nameservers",
"type": "Array"
},
{
"name": "options",
"baseName": "options",
"type": "Array"
},
{
"name": "searches",
"baseName": "searches",
"type": "Array"
}
];
exports.V1PodDNSConfig = V1PodDNSConfig;
/**
* PodDNSConfigOption defines DNS resolver options of a pod.
*/
class V1PodDNSConfigOption {
static getAttributeTypeMap() {
return V1PodDNSConfigOption.attributeTypeMap;
}
}
V1PodDNSConfigOption.discriminator = undefined;
V1PodDNSConfigOption.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "value",
"baseName": "value",
"type": "string"
}
];
exports.V1PodDNSConfigOption = V1PodDNSConfigOption;
/**
* PodList is a list of Pods.
*/
class V1PodList {
static getAttributeTypeMap() {
return V1PodList.attributeTypeMap;
}
}
V1PodList.discriminator = undefined;
V1PodList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1PodList = V1PodList;
/**
* PodReadinessGate contains the reference to a pod condition
*/
class V1PodReadinessGate {
static getAttributeTypeMap() {
return V1PodReadinessGate.attributeTypeMap;
}
}
V1PodReadinessGate.discriminator = undefined;
V1PodReadinessGate.attributeTypeMap = [
{
"name": "conditionType",
"baseName": "conditionType",
"type": "string"
}
];
exports.V1PodReadinessGate = V1PodReadinessGate;
/**
* 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.
*/
class V1PodSecurityContext {
static getAttributeTypeMap() {
return V1PodSecurityContext.attributeTypeMap;
}
}
V1PodSecurityContext.discriminator = undefined;
V1PodSecurityContext.attributeTypeMap = [
{
"name": "fsGroup",
"baseName": "fsGroup",
"type": "number"
},
{
"name": "runAsGroup",
"baseName": "runAsGroup",
"type": "number"
},
{
"name": "runAsNonRoot",
"baseName": "runAsNonRoot",
"type": "boolean"
},
{
"name": "runAsUser",
"baseName": "runAsUser",
"type": "number"
},
{
"name": "seLinuxOptions",
"baseName": "seLinuxOptions",
"type": "V1SELinuxOptions"
},
{
"name": "supplementalGroups",
"baseName": "supplementalGroups",
"type": "Array"
},
{
"name": "sysctls",
"baseName": "sysctls",
"type": "Array"
}
];
exports.V1PodSecurityContext = V1PodSecurityContext;
/**
* PodSpec is a description of a pod.
*/
class V1PodSpec {
static getAttributeTypeMap() {
return V1PodSpec.attributeTypeMap;
}
}
V1PodSpec.discriminator = undefined;
V1PodSpec.attributeTypeMap = [
{
"name": "activeDeadlineSeconds",
"baseName": "activeDeadlineSeconds",
"type": "number"
},
{
"name": "affinity",
"baseName": "affinity",
"type": "V1Affinity"
},
{
"name": "automountServiceAccountToken",
"baseName": "automountServiceAccountToken",
"type": "boolean"
},
{
"name": "containers",
"baseName": "containers",
"type": "Array"
},
{
"name": "dnsConfig",
"baseName": "dnsConfig",
"type": "V1PodDNSConfig"
},
{
"name": "dnsPolicy",
"baseName": "dnsPolicy",
"type": "string"
},
{
"name": "enableServiceLinks",
"baseName": "enableServiceLinks",
"type": "boolean"
},
{
"name": "hostAliases",
"baseName": "hostAliases",
"type": "Array"
},
{
"name": "hostIPC",
"baseName": "hostIPC",
"type": "boolean"
},
{
"name": "hostNetwork",
"baseName": "hostNetwork",
"type": "boolean"
},
{
"name": "hostPID",
"baseName": "hostPID",
"type": "boolean"
},
{
"name": "hostname",
"baseName": "hostname",
"type": "string"
},
{
"name": "imagePullSecrets",
"baseName": "imagePullSecrets",
"type": "Array"
},
{
"name": "initContainers",
"baseName": "initContainers",
"type": "Array"
},
{
"name": "nodeName",
"baseName": "nodeName",
"type": "string"
},
{
"name": "nodeSelector",
"baseName": "nodeSelector",
"type": "{ [key: string]: string; }"
},
{
"name": "priority",
"baseName": "priority",
"type": "number"
},
{
"name": "priorityClassName",
"baseName": "priorityClassName",
"type": "string"
},
{
"name": "readinessGates",
"baseName": "readinessGates",
"type": "Array"
},
{
"name": "restartPolicy",
"baseName": "restartPolicy",
"type": "string"
},
{
"name": "runtimeClassName",
"baseName": "runtimeClassName",
"type": "string"
},
{
"name": "schedulerName",
"baseName": "schedulerName",
"type": "string"
},
{
"name": "securityContext",
"baseName": "securityContext",
"type": "V1PodSecurityContext"
},
{
"name": "serviceAccount",
"baseName": "serviceAccount",
"type": "string"
},
{
"name": "serviceAccountName",
"baseName": "serviceAccountName",
"type": "string"
},
{
"name": "shareProcessNamespace",
"baseName": "shareProcessNamespace",
"type": "boolean"
},
{
"name": "subdomain",
"baseName": "subdomain",
"type": "string"
},
{
"name": "terminationGracePeriodSeconds",
"baseName": "terminationGracePeriodSeconds",
"type": "number"
},
{
"name": "tolerations",
"baseName": "tolerations",
"type": "Array"
},
{
"name": "volumes",
"baseName": "volumes",
"type": "Array"
}
];
exports.V1PodSpec = V1PodSpec;
/**
* 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.
*/
class V1PodStatus {
static getAttributeTypeMap() {
return V1PodStatus.attributeTypeMap;
}
}
V1PodStatus.discriminator = undefined;
V1PodStatus.attributeTypeMap = [
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "containerStatuses",
"baseName": "containerStatuses",
"type": "Array"
},
{
"name": "hostIP",
"baseName": "hostIP",
"type": "string"
},
{
"name": "initContainerStatuses",
"baseName": "initContainerStatuses",
"type": "Array"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "nominatedNodeName",
"baseName": "nominatedNodeName",
"type": "string"
},
{
"name": "phase",
"baseName": "phase",
"type": "string"
},
{
"name": "podIP",
"baseName": "podIP",
"type": "string"
},
{
"name": "qosClass",
"baseName": "qosClass",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "startTime",
"baseName": "startTime",
"type": "Date"
}
];
exports.V1PodStatus = V1PodStatus;
/**
* PodTemplate describes a template for creating copies of a predefined pod.
*/
class V1PodTemplate {
static getAttributeTypeMap() {
return V1PodTemplate.attributeTypeMap;
}
}
V1PodTemplate.discriminator = undefined;
V1PodTemplate.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "template",
"baseName": "template",
"type": "V1PodTemplateSpec"
}
];
exports.V1PodTemplate = V1PodTemplate;
/**
* PodTemplateList is a list of PodTemplates.
*/
class V1PodTemplateList {
static getAttributeTypeMap() {
return V1PodTemplateList.attributeTypeMap;
}
}
V1PodTemplateList.discriminator = undefined;
V1PodTemplateList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1PodTemplateList = V1PodTemplateList;
/**
* PodTemplateSpec describes the data a pod should have when created from a template
*/
class V1PodTemplateSpec {
static getAttributeTypeMap() {
return V1PodTemplateSpec.attributeTypeMap;
}
}
V1PodTemplateSpec.discriminator = undefined;
V1PodTemplateSpec.attributeTypeMap = [
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1PodSpec"
}
];
exports.V1PodTemplateSpec = V1PodTemplateSpec;
/**
* 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.
*/
class V1PolicyRule {
static getAttributeTypeMap() {
return V1PolicyRule.attributeTypeMap;
}
}
V1PolicyRule.discriminator = undefined;
V1PolicyRule.attributeTypeMap = [
{
"name": "apiGroups",
"baseName": "apiGroups",
"type": "Array"
},
{
"name": "nonResourceURLs",
"baseName": "nonResourceURLs",
"type": "Array"
},
{
"name": "resourceNames",
"baseName": "resourceNames",
"type": "Array"
},
{
"name": "resources",
"baseName": "resources",
"type": "Array"
},
{
"name": "verbs",
"baseName": "verbs",
"type": "Array"
}
];
exports.V1PolicyRule = V1PolicyRule;
/**
* PortworxVolumeSource represents a Portworx volume resource.
*/
class V1PortworxVolumeSource {
static getAttributeTypeMap() {
return V1PortworxVolumeSource.attributeTypeMap;
}
}
V1PortworxVolumeSource.discriminator = undefined;
V1PortworxVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "volumeID",
"baseName": "volumeID",
"type": "string"
}
];
exports.V1PortworxVolumeSource = V1PortworxVolumeSource;
/**
* Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.
*/
class V1Preconditions {
static getAttributeTypeMap() {
return V1Preconditions.attributeTypeMap;
}
}
V1Preconditions.discriminator = undefined;
V1Preconditions.attributeTypeMap = [
{
"name": "uid",
"baseName": "uid",
"type": "string"
}
];
exports.V1Preconditions = V1Preconditions;
/**
* 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).
*/
class V1PreferredSchedulingTerm {
static getAttributeTypeMap() {
return V1PreferredSchedulingTerm.attributeTypeMap;
}
}
V1PreferredSchedulingTerm.discriminator = undefined;
V1PreferredSchedulingTerm.attributeTypeMap = [
{
"name": "preference",
"baseName": "preference",
"type": "V1NodeSelectorTerm"
},
{
"name": "weight",
"baseName": "weight",
"type": "number"
}
];
exports.V1PreferredSchedulingTerm = V1PreferredSchedulingTerm;
/**
* Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.
*/
class V1Probe {
static getAttributeTypeMap() {
return V1Probe.attributeTypeMap;
}
}
V1Probe.discriminator = undefined;
V1Probe.attributeTypeMap = [
{
"name": "exec",
"baseName": "exec",
"type": "V1ExecAction"
},
{
"name": "failureThreshold",
"baseName": "failureThreshold",
"type": "number"
},
{
"name": "httpGet",
"baseName": "httpGet",
"type": "V1HTTPGetAction"
},
{
"name": "initialDelaySeconds",
"baseName": "initialDelaySeconds",
"type": "number"
},
{
"name": "periodSeconds",
"baseName": "periodSeconds",
"type": "number"
},
{
"name": "successThreshold",
"baseName": "successThreshold",
"type": "number"
},
{
"name": "tcpSocket",
"baseName": "tcpSocket",
"type": "V1TCPSocketAction"
},
{
"name": "timeoutSeconds",
"baseName": "timeoutSeconds",
"type": "number"
}
];
exports.V1Probe = V1Probe;
/**
* Represents a projected volume source
*/
class V1ProjectedVolumeSource {
static getAttributeTypeMap() {
return V1ProjectedVolumeSource.attributeTypeMap;
}
}
V1ProjectedVolumeSource.discriminator = undefined;
V1ProjectedVolumeSource.attributeTypeMap = [
{
"name": "defaultMode",
"baseName": "defaultMode",
"type": "number"
},
{
"name": "sources",
"baseName": "sources",
"type": "Array"
}
];
exports.V1ProjectedVolumeSource = V1ProjectedVolumeSource;
/**
* Represents a Quobyte mount that lasts the lifetime of a pod. Quobyte volumes do not support ownership management or SELinux relabeling.
*/
class V1QuobyteVolumeSource {
static getAttributeTypeMap() {
return V1QuobyteVolumeSource.attributeTypeMap;
}
}
V1QuobyteVolumeSource.discriminator = undefined;
V1QuobyteVolumeSource.attributeTypeMap = [
{
"name": "group",
"baseName": "group",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "registry",
"baseName": "registry",
"type": "string"
},
{
"name": "user",
"baseName": "user",
"type": "string"
},
{
"name": "volume",
"baseName": "volume",
"type": "string"
}
];
exports.V1QuobyteVolumeSource = V1QuobyteVolumeSource;
/**
* Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.
*/
class V1RBDPersistentVolumeSource {
static getAttributeTypeMap() {
return V1RBDPersistentVolumeSource.attributeTypeMap;
}
}
V1RBDPersistentVolumeSource.discriminator = undefined;
V1RBDPersistentVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "image",
"baseName": "image",
"type": "string"
},
{
"name": "keyring",
"baseName": "keyring",
"type": "string"
},
{
"name": "monitors",
"baseName": "monitors",
"type": "Array"
},
{
"name": "pool",
"baseName": "pool",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1SecretReference"
},
{
"name": "user",
"baseName": "user",
"type": "string"
}
];
exports.V1RBDPersistentVolumeSource = V1RBDPersistentVolumeSource;
/**
* Represents a Rados Block Device mount that lasts the lifetime of a pod. RBD volumes support ownership management and SELinux relabeling.
*/
class V1RBDVolumeSource {
static getAttributeTypeMap() {
return V1RBDVolumeSource.attributeTypeMap;
}
}
V1RBDVolumeSource.discriminator = undefined;
V1RBDVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "image",
"baseName": "image",
"type": "string"
},
{
"name": "keyring",
"baseName": "keyring",
"type": "string"
},
{
"name": "monitors",
"baseName": "monitors",
"type": "Array"
},
{
"name": "pool",
"baseName": "pool",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1LocalObjectReference"
},
{
"name": "user",
"baseName": "user",
"type": "string"
}
];
exports.V1RBDVolumeSource = V1RBDVolumeSource;
/**
* ReplicaSet ensures that a specified number of pod replicas are running at any given time.
*/
class V1ReplicaSet {
static getAttributeTypeMap() {
return V1ReplicaSet.attributeTypeMap;
}
}
V1ReplicaSet.discriminator = undefined;
V1ReplicaSet.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1ReplicaSetSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1ReplicaSetStatus"
}
];
exports.V1ReplicaSet = V1ReplicaSet;
/**
* ReplicaSetCondition describes the state of a replica set at a certain point.
*/
class V1ReplicaSetCondition {
static getAttributeTypeMap() {
return V1ReplicaSetCondition.attributeTypeMap;
}
}
V1ReplicaSetCondition.discriminator = undefined;
V1ReplicaSetCondition.attributeTypeMap = [
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1ReplicaSetCondition = V1ReplicaSetCondition;
/**
* ReplicaSetList is a collection of ReplicaSets.
*/
class V1ReplicaSetList {
static getAttributeTypeMap() {
return V1ReplicaSetList.attributeTypeMap;
}
}
V1ReplicaSetList.discriminator = undefined;
V1ReplicaSetList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1ReplicaSetList = V1ReplicaSetList;
/**
* ReplicaSetSpec is the specification of a ReplicaSet.
*/
class V1ReplicaSetSpec {
static getAttributeTypeMap() {
return V1ReplicaSetSpec.attributeTypeMap;
}
}
V1ReplicaSetSpec.discriminator = undefined;
V1ReplicaSetSpec.attributeTypeMap = [
{
"name": "minReadySeconds",
"baseName": "minReadySeconds",
"type": "number"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "selector",
"baseName": "selector",
"type": "V1LabelSelector"
},
{
"name": "template",
"baseName": "template",
"type": "V1PodTemplateSpec"
}
];
exports.V1ReplicaSetSpec = V1ReplicaSetSpec;
/**
* ReplicaSetStatus represents the current status of a ReplicaSet.
*/
class V1ReplicaSetStatus {
static getAttributeTypeMap() {
return V1ReplicaSetStatus.attributeTypeMap;
}
}
V1ReplicaSetStatus.discriminator = undefined;
V1ReplicaSetStatus.attributeTypeMap = [
{
"name": "availableReplicas",
"baseName": "availableReplicas",
"type": "number"
},
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "fullyLabeledReplicas",
"baseName": "fullyLabeledReplicas",
"type": "number"
},
{
"name": "observedGeneration",
"baseName": "observedGeneration",
"type": "number"
},
{
"name": "readyReplicas",
"baseName": "readyReplicas",
"type": "number"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
}
];
exports.V1ReplicaSetStatus = V1ReplicaSetStatus;
/**
* ReplicationController represents the configuration of a replication controller.
*/
class V1ReplicationController {
static getAttributeTypeMap() {
return V1ReplicationController.attributeTypeMap;
}
}
V1ReplicationController.discriminator = undefined;
V1ReplicationController.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1ReplicationControllerSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1ReplicationControllerStatus"
}
];
exports.V1ReplicationController = V1ReplicationController;
/**
* ReplicationControllerCondition describes the state of a replication controller at a certain point.
*/
class V1ReplicationControllerCondition {
static getAttributeTypeMap() {
return V1ReplicationControllerCondition.attributeTypeMap;
}
}
V1ReplicationControllerCondition.discriminator = undefined;
V1ReplicationControllerCondition.attributeTypeMap = [
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1ReplicationControllerCondition = V1ReplicationControllerCondition;
/**
* ReplicationControllerList is a collection of replication controllers.
*/
class V1ReplicationControllerList {
static getAttributeTypeMap() {
return V1ReplicationControllerList.attributeTypeMap;
}
}
V1ReplicationControllerList.discriminator = undefined;
V1ReplicationControllerList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1ReplicationControllerList = V1ReplicationControllerList;
/**
* ReplicationControllerSpec is the specification of a replication controller.
*/
class V1ReplicationControllerSpec {
static getAttributeTypeMap() {
return V1ReplicationControllerSpec.attributeTypeMap;
}
}
V1ReplicationControllerSpec.discriminator = undefined;
V1ReplicationControllerSpec.attributeTypeMap = [
{
"name": "minReadySeconds",
"baseName": "minReadySeconds",
"type": "number"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "selector",
"baseName": "selector",
"type": "{ [key: string]: string; }"
},
{
"name": "template",
"baseName": "template",
"type": "V1PodTemplateSpec"
}
];
exports.V1ReplicationControllerSpec = V1ReplicationControllerSpec;
/**
* ReplicationControllerStatus represents the current status of a replication controller.
*/
class V1ReplicationControllerStatus {
static getAttributeTypeMap() {
return V1ReplicationControllerStatus.attributeTypeMap;
}
}
V1ReplicationControllerStatus.discriminator = undefined;
V1ReplicationControllerStatus.attributeTypeMap = [
{
"name": "availableReplicas",
"baseName": "availableReplicas",
"type": "number"
},
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "fullyLabeledReplicas",
"baseName": "fullyLabeledReplicas",
"type": "number"
},
{
"name": "observedGeneration",
"baseName": "observedGeneration",
"type": "number"
},
{
"name": "readyReplicas",
"baseName": "readyReplicas",
"type": "number"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
}
];
exports.V1ReplicationControllerStatus = V1ReplicationControllerStatus;
/**
* ResourceAttributes includes the authorization attributes available for resource requests to the Authorizer interface
*/
class V1ResourceAttributes {
static getAttributeTypeMap() {
return V1ResourceAttributes.attributeTypeMap;
}
}
V1ResourceAttributes.discriminator = undefined;
V1ResourceAttributes.attributeTypeMap = [
{
"name": "group",
"baseName": "group",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
},
{
"name": "resource",
"baseName": "resource",
"type": "string"
},
{
"name": "subresource",
"baseName": "subresource",
"type": "string"
},
{
"name": "verb",
"baseName": "verb",
"type": "string"
},
{
"name": "version",
"baseName": "version",
"type": "string"
}
];
exports.V1ResourceAttributes = V1ResourceAttributes;
/**
* ResourceFieldSelector represents container resources (cpu, memory) and their output format
*/
class V1ResourceFieldSelector {
static getAttributeTypeMap() {
return V1ResourceFieldSelector.attributeTypeMap;
}
}
V1ResourceFieldSelector.discriminator = undefined;
V1ResourceFieldSelector.attributeTypeMap = [
{
"name": "containerName",
"baseName": "containerName",
"type": "string"
},
{
"name": "divisor",
"baseName": "divisor",
"type": "string"
},
{
"name": "resource",
"baseName": "resource",
"type": "string"
}
];
exports.V1ResourceFieldSelector = V1ResourceFieldSelector;
/**
* ResourceQuota sets aggregate quota restrictions enforced per namespace
*/
class V1ResourceQuota {
static getAttributeTypeMap() {
return V1ResourceQuota.attributeTypeMap;
}
}
V1ResourceQuota.discriminator = undefined;
V1ResourceQuota.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1ResourceQuotaSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1ResourceQuotaStatus"
}
];
exports.V1ResourceQuota = V1ResourceQuota;
/**
* ResourceQuotaList is a list of ResourceQuota items.
*/
class V1ResourceQuotaList {
static getAttributeTypeMap() {
return V1ResourceQuotaList.attributeTypeMap;
}
}
V1ResourceQuotaList.discriminator = undefined;
V1ResourceQuotaList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1ResourceQuotaList = V1ResourceQuotaList;
/**
* ResourceQuotaSpec defines the desired hard limits to enforce for Quota.
*/
class V1ResourceQuotaSpec {
static getAttributeTypeMap() {
return V1ResourceQuotaSpec.attributeTypeMap;
}
}
V1ResourceQuotaSpec.discriminator = undefined;
V1ResourceQuotaSpec.attributeTypeMap = [
{
"name": "hard",
"baseName": "hard",
"type": "{ [key: string]: string; }"
},
{
"name": "scopeSelector",
"baseName": "scopeSelector",
"type": "V1ScopeSelector"
},
{
"name": "scopes",
"baseName": "scopes",
"type": "Array"
}
];
exports.V1ResourceQuotaSpec = V1ResourceQuotaSpec;
/**
* ResourceQuotaStatus defines the enforced hard limits and observed use.
*/
class V1ResourceQuotaStatus {
static getAttributeTypeMap() {
return V1ResourceQuotaStatus.attributeTypeMap;
}
}
V1ResourceQuotaStatus.discriminator = undefined;
V1ResourceQuotaStatus.attributeTypeMap = [
{
"name": "hard",
"baseName": "hard",
"type": "{ [key: string]: string; }"
},
{
"name": "used",
"baseName": "used",
"type": "{ [key: string]: string; }"
}
];
exports.V1ResourceQuotaStatus = V1ResourceQuotaStatus;
/**
* ResourceRequirements describes the compute resource requirements.
*/
class V1ResourceRequirements {
static getAttributeTypeMap() {
return V1ResourceRequirements.attributeTypeMap;
}
}
V1ResourceRequirements.discriminator = undefined;
V1ResourceRequirements.attributeTypeMap = [
{
"name": "limits",
"baseName": "limits",
"type": "{ [key: string]: string; }"
},
{
"name": "requests",
"baseName": "requests",
"type": "{ [key: string]: string; }"
}
];
exports.V1ResourceRequirements = V1ResourceRequirements;
/**
* 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.
*/
class V1ResourceRule {
static getAttributeTypeMap() {
return V1ResourceRule.attributeTypeMap;
}
}
V1ResourceRule.discriminator = undefined;
V1ResourceRule.attributeTypeMap = [
{
"name": "apiGroups",
"baseName": "apiGroups",
"type": "Array"
},
{
"name": "resourceNames",
"baseName": "resourceNames",
"type": "Array"
},
{
"name": "resources",
"baseName": "resources",
"type": "Array"
},
{
"name": "verbs",
"baseName": "verbs",
"type": "Array"
}
];
exports.V1ResourceRule = V1ResourceRule;
/**
* Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding.
*/
class V1Role {
static getAttributeTypeMap() {
return V1Role.attributeTypeMap;
}
}
V1Role.discriminator = undefined;
V1Role.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "rules",
"baseName": "rules",
"type": "Array"
}
];
exports.V1Role = V1Role;
/**
* 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.
*/
class V1RoleBinding {
static getAttributeTypeMap() {
return V1RoleBinding.attributeTypeMap;
}
}
V1RoleBinding.discriminator = undefined;
V1RoleBinding.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "roleRef",
"baseName": "roleRef",
"type": "V1RoleRef"
},
{
"name": "subjects",
"baseName": "subjects",
"type": "Array"
}
];
exports.V1RoleBinding = V1RoleBinding;
/**
* RoleBindingList is a collection of RoleBindings
*/
class V1RoleBindingList {
static getAttributeTypeMap() {
return V1RoleBindingList.attributeTypeMap;
}
}
V1RoleBindingList.discriminator = undefined;
V1RoleBindingList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1RoleBindingList = V1RoleBindingList;
/**
* RoleList is a collection of Roles
*/
class V1RoleList {
static getAttributeTypeMap() {
return V1RoleList.attributeTypeMap;
}
}
V1RoleList.discriminator = undefined;
V1RoleList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1RoleList = V1RoleList;
/**
* RoleRef contains information that points to the role being used
*/
class V1RoleRef {
static getAttributeTypeMap() {
return V1RoleRef.attributeTypeMap;
}
}
V1RoleRef.discriminator = undefined;
V1RoleRef.attributeTypeMap = [
{
"name": "apiGroup",
"baseName": "apiGroup",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
}
];
exports.V1RoleRef = V1RoleRef;
/**
* Spec to control the desired behavior of daemon set rolling update.
*/
class V1RollingUpdateDaemonSet {
static getAttributeTypeMap() {
return V1RollingUpdateDaemonSet.attributeTypeMap;
}
}
V1RollingUpdateDaemonSet.discriminator = undefined;
V1RollingUpdateDaemonSet.attributeTypeMap = [
{
"name": "maxUnavailable",
"baseName": "maxUnavailable",
"type": "any"
}
];
exports.V1RollingUpdateDaemonSet = V1RollingUpdateDaemonSet;
/**
* Spec to control the desired behavior of rolling update.
*/
class V1RollingUpdateDeployment {
static getAttributeTypeMap() {
return V1RollingUpdateDeployment.attributeTypeMap;
}
}
V1RollingUpdateDeployment.discriminator = undefined;
V1RollingUpdateDeployment.attributeTypeMap = [
{
"name": "maxSurge",
"baseName": "maxSurge",
"type": "any"
},
{
"name": "maxUnavailable",
"baseName": "maxUnavailable",
"type": "any"
}
];
exports.V1RollingUpdateDeployment = V1RollingUpdateDeployment;
/**
* RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType.
*/
class V1RollingUpdateStatefulSetStrategy {
static getAttributeTypeMap() {
return V1RollingUpdateStatefulSetStrategy.attributeTypeMap;
}
}
V1RollingUpdateStatefulSetStrategy.discriminator = undefined;
V1RollingUpdateStatefulSetStrategy.attributeTypeMap = [
{
"name": "partition",
"baseName": "partition",
"type": "number"
}
];
exports.V1RollingUpdateStatefulSetStrategy = V1RollingUpdateStatefulSetStrategy;
/**
* SELinuxOptions are the labels to be applied to the container
*/
class V1SELinuxOptions {
static getAttributeTypeMap() {
return V1SELinuxOptions.attributeTypeMap;
}
}
V1SELinuxOptions.discriminator = undefined;
V1SELinuxOptions.attributeTypeMap = [
{
"name": "level",
"baseName": "level",
"type": "string"
},
{
"name": "role",
"baseName": "role",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
},
{
"name": "user",
"baseName": "user",
"type": "string"
}
];
exports.V1SELinuxOptions = V1SELinuxOptions;
/**
* Scale represents a scaling request for a resource.
*/
class V1Scale {
static getAttributeTypeMap() {
return V1Scale.attributeTypeMap;
}
}
V1Scale.discriminator = undefined;
V1Scale.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1ScaleSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1ScaleStatus"
}
];
exports.V1Scale = V1Scale;
/**
* ScaleIOPersistentVolumeSource represents a persistent ScaleIO volume
*/
class V1ScaleIOPersistentVolumeSource {
static getAttributeTypeMap() {
return V1ScaleIOPersistentVolumeSource.attributeTypeMap;
}
}
V1ScaleIOPersistentVolumeSource.discriminator = undefined;
V1ScaleIOPersistentVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "gateway",
"baseName": "gateway",
"type": "string"
},
{
"name": "protectionDomain",
"baseName": "protectionDomain",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1SecretReference"
},
{
"name": "sslEnabled",
"baseName": "sslEnabled",
"type": "boolean"
},
{
"name": "storageMode",
"baseName": "storageMode",
"type": "string"
},
{
"name": "storagePool",
"baseName": "storagePool",
"type": "string"
},
{
"name": "system",
"baseName": "system",
"type": "string"
},
{
"name": "volumeName",
"baseName": "volumeName",
"type": "string"
}
];
exports.V1ScaleIOPersistentVolumeSource = V1ScaleIOPersistentVolumeSource;
/**
* ScaleIOVolumeSource represents a persistent ScaleIO volume
*/
class V1ScaleIOVolumeSource {
static getAttributeTypeMap() {
return V1ScaleIOVolumeSource.attributeTypeMap;
}
}
V1ScaleIOVolumeSource.discriminator = undefined;
V1ScaleIOVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "gateway",
"baseName": "gateway",
"type": "string"
},
{
"name": "protectionDomain",
"baseName": "protectionDomain",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1LocalObjectReference"
},
{
"name": "sslEnabled",
"baseName": "sslEnabled",
"type": "boolean"
},
{
"name": "storageMode",
"baseName": "storageMode",
"type": "string"
},
{
"name": "storagePool",
"baseName": "storagePool",
"type": "string"
},
{
"name": "system",
"baseName": "system",
"type": "string"
},
{
"name": "volumeName",
"baseName": "volumeName",
"type": "string"
}
];
exports.V1ScaleIOVolumeSource = V1ScaleIOVolumeSource;
/**
* ScaleSpec describes the attributes of a scale subresource.
*/
class V1ScaleSpec {
static getAttributeTypeMap() {
return V1ScaleSpec.attributeTypeMap;
}
}
V1ScaleSpec.discriminator = undefined;
V1ScaleSpec.attributeTypeMap = [
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
}
];
exports.V1ScaleSpec = V1ScaleSpec;
/**
* ScaleStatus represents the current status of a scale subresource.
*/
class V1ScaleStatus {
static getAttributeTypeMap() {
return V1ScaleStatus.attributeTypeMap;
}
}
V1ScaleStatus.discriminator = undefined;
V1ScaleStatus.attributeTypeMap = [
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "selector",
"baseName": "selector",
"type": "string"
}
];
exports.V1ScaleStatus = V1ScaleStatus;
/**
* A scope selector represents the AND of the selectors represented by the scoped-resource selector requirements.
*/
class V1ScopeSelector {
static getAttributeTypeMap() {
return V1ScopeSelector.attributeTypeMap;
}
}
V1ScopeSelector.discriminator = undefined;
V1ScopeSelector.attributeTypeMap = [
{
"name": "matchExpressions",
"baseName": "matchExpressions",
"type": "Array"
}
];
exports.V1ScopeSelector = V1ScopeSelector;
/**
* A scoped-resource selector requirement is a selector that contains values, a scope name, and an operator that relates the scope name and values.
*/
class V1ScopedResourceSelectorRequirement {
static getAttributeTypeMap() {
return V1ScopedResourceSelectorRequirement.attributeTypeMap;
}
}
V1ScopedResourceSelectorRequirement.discriminator = undefined;
V1ScopedResourceSelectorRequirement.attributeTypeMap = [
{
"name": "operator",
"baseName": "operator",
"type": "string"
},
{
"name": "scopeName",
"baseName": "scopeName",
"type": "string"
},
{
"name": "values",
"baseName": "values",
"type": "Array"
}
];
exports.V1ScopedResourceSelectorRequirement = V1ScopedResourceSelectorRequirement;
/**
* Secret holds secret data of a certain type. The total bytes of the values in the Data field must be less than MaxSecretSize bytes.
*/
class V1Secret {
static getAttributeTypeMap() {
return V1Secret.attributeTypeMap;
}
}
V1Secret.discriminator = undefined;
V1Secret.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "data",
"baseName": "data",
"type": "{ [key: string]: string; }"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "stringData",
"baseName": "stringData",
"type": "{ [key: string]: string; }"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1Secret = V1Secret;
/**
* 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.
*/
class V1SecretEnvSource {
static getAttributeTypeMap() {
return V1SecretEnvSource.attributeTypeMap;
}
}
V1SecretEnvSource.discriminator = undefined;
V1SecretEnvSource.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "optional",
"baseName": "optional",
"type": "boolean"
}
];
exports.V1SecretEnvSource = V1SecretEnvSource;
/**
* SecretKeySelector selects a key of a Secret.
*/
class V1SecretKeySelector {
static getAttributeTypeMap() {
return V1SecretKeySelector.attributeTypeMap;
}
}
V1SecretKeySelector.discriminator = undefined;
V1SecretKeySelector.attributeTypeMap = [
{
"name": "key",
"baseName": "key",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "optional",
"baseName": "optional",
"type": "boolean"
}
];
exports.V1SecretKeySelector = V1SecretKeySelector;
/**
* SecretList is a list of Secret.
*/
class V1SecretList {
static getAttributeTypeMap() {
return V1SecretList.attributeTypeMap;
}
}
V1SecretList.discriminator = undefined;
V1SecretList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1SecretList = V1SecretList;
/**
* 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.
*/
class V1SecretProjection {
static getAttributeTypeMap() {
return V1SecretProjection.attributeTypeMap;
}
}
V1SecretProjection.discriminator = undefined;
V1SecretProjection.attributeTypeMap = [
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "optional",
"baseName": "optional",
"type": "boolean"
}
];
exports.V1SecretProjection = V1SecretProjection;
/**
* SecretReference represents a Secret Reference. It has enough information to retrieve secret in any namespace
*/
class V1SecretReference {
static getAttributeTypeMap() {
return V1SecretReference.attributeTypeMap;
}
}
V1SecretReference.discriminator = undefined;
V1SecretReference.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
}
];
exports.V1SecretReference = V1SecretReference;
/**
* 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.
*/
class V1SecretVolumeSource {
static getAttributeTypeMap() {
return V1SecretVolumeSource.attributeTypeMap;
}
}
V1SecretVolumeSource.discriminator = undefined;
V1SecretVolumeSource.attributeTypeMap = [
{
"name": "defaultMode",
"baseName": "defaultMode",
"type": "number"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "optional",
"baseName": "optional",
"type": "boolean"
},
{
"name": "secretName",
"baseName": "secretName",
"type": "string"
}
];
exports.V1SecretVolumeSource = V1SecretVolumeSource;
/**
* 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.
*/
class V1SecurityContext {
static getAttributeTypeMap() {
return V1SecurityContext.attributeTypeMap;
}
}
V1SecurityContext.discriminator = undefined;
V1SecurityContext.attributeTypeMap = [
{
"name": "allowPrivilegeEscalation",
"baseName": "allowPrivilegeEscalation",
"type": "boolean"
},
{
"name": "capabilities",
"baseName": "capabilities",
"type": "V1Capabilities"
},
{
"name": "privileged",
"baseName": "privileged",
"type": "boolean"
},
{
"name": "procMount",
"baseName": "procMount",
"type": "string"
},
{
"name": "readOnlyRootFilesystem",
"baseName": "readOnlyRootFilesystem",
"type": "boolean"
},
{
"name": "runAsGroup",
"baseName": "runAsGroup",
"type": "number"
},
{
"name": "runAsNonRoot",
"baseName": "runAsNonRoot",
"type": "boolean"
},
{
"name": "runAsUser",
"baseName": "runAsUser",
"type": "number"
},
{
"name": "seLinuxOptions",
"baseName": "seLinuxOptions",
"type": "V1SELinuxOptions"
}
];
exports.V1SecurityContext = V1SecurityContext;
/**
* 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
*/
class V1SelfSubjectAccessReview {
static getAttributeTypeMap() {
return V1SelfSubjectAccessReview.attributeTypeMap;
}
}
V1SelfSubjectAccessReview.discriminator = undefined;
V1SelfSubjectAccessReview.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1SelfSubjectAccessReviewSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1SubjectAccessReviewStatus"
}
];
exports.V1SelfSubjectAccessReview = V1SelfSubjectAccessReview;
/**
* SelfSubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set
*/
class V1SelfSubjectAccessReviewSpec {
static getAttributeTypeMap() {
return V1SelfSubjectAccessReviewSpec.attributeTypeMap;
}
}
V1SelfSubjectAccessReviewSpec.discriminator = undefined;
V1SelfSubjectAccessReviewSpec.attributeTypeMap = [
{
"name": "nonResourceAttributes",
"baseName": "nonResourceAttributes",
"type": "V1NonResourceAttributes"
},
{
"name": "resourceAttributes",
"baseName": "resourceAttributes",
"type": "V1ResourceAttributes"
}
];
exports.V1SelfSubjectAccessReviewSpec = V1SelfSubjectAccessReviewSpec;
/**
* 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.
*/
class V1SelfSubjectRulesReview {
static getAttributeTypeMap() {
return V1SelfSubjectRulesReview.attributeTypeMap;
}
}
V1SelfSubjectRulesReview.discriminator = undefined;
V1SelfSubjectRulesReview.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1SelfSubjectRulesReviewSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1SubjectRulesReviewStatus"
}
];
exports.V1SelfSubjectRulesReview = V1SelfSubjectRulesReview;
class V1SelfSubjectRulesReviewSpec {
static getAttributeTypeMap() {
return V1SelfSubjectRulesReviewSpec.attributeTypeMap;
}
}
V1SelfSubjectRulesReviewSpec.discriminator = undefined;
V1SelfSubjectRulesReviewSpec.attributeTypeMap = [
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
}
];
exports.V1SelfSubjectRulesReviewSpec = V1SelfSubjectRulesReviewSpec;
/**
* ServerAddressByClientCIDR helps the client to determine the server address that they should use, depending on the clientCIDR that they match.
*/
class V1ServerAddressByClientCIDR {
static getAttributeTypeMap() {
return V1ServerAddressByClientCIDR.attributeTypeMap;
}
}
V1ServerAddressByClientCIDR.discriminator = undefined;
V1ServerAddressByClientCIDR.attributeTypeMap = [
{
"name": "clientCIDR",
"baseName": "clientCIDR",
"type": "string"
},
{
"name": "serverAddress",
"baseName": "serverAddress",
"type": "string"
}
];
exports.V1ServerAddressByClientCIDR = V1ServerAddressByClientCIDR;
/**
* 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.
*/
class V1Service {
static getAttributeTypeMap() {
return V1Service.attributeTypeMap;
}
}
V1Service.discriminator = undefined;
V1Service.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1ServiceSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1ServiceStatus"
}
];
exports.V1Service = V1Service;
/**
* 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
*/
class V1ServiceAccount {
static getAttributeTypeMap() {
return V1ServiceAccount.attributeTypeMap;
}
}
V1ServiceAccount.discriminator = undefined;
V1ServiceAccount.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "automountServiceAccountToken",
"baseName": "automountServiceAccountToken",
"type": "boolean"
},
{
"name": "imagePullSecrets",
"baseName": "imagePullSecrets",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "secrets",
"baseName": "secrets",
"type": "Array"
}
];
exports.V1ServiceAccount = V1ServiceAccount;
/**
* ServiceAccountList is a list of ServiceAccount objects
*/
class V1ServiceAccountList {
static getAttributeTypeMap() {
return V1ServiceAccountList.attributeTypeMap;
}
}
V1ServiceAccountList.discriminator = undefined;
V1ServiceAccountList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1ServiceAccountList = V1ServiceAccountList;
/**
* 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).
*/
class V1ServiceAccountTokenProjection {
static getAttributeTypeMap() {
return V1ServiceAccountTokenProjection.attributeTypeMap;
}
}
V1ServiceAccountTokenProjection.discriminator = undefined;
V1ServiceAccountTokenProjection.attributeTypeMap = [
{
"name": "audience",
"baseName": "audience",
"type": "string"
},
{
"name": "expirationSeconds",
"baseName": "expirationSeconds",
"type": "number"
},
{
"name": "path",
"baseName": "path",
"type": "string"
}
];
exports.V1ServiceAccountTokenProjection = V1ServiceAccountTokenProjection;
/**
* ServiceList holds a list of services.
*/
class V1ServiceList {
static getAttributeTypeMap() {
return V1ServiceList.attributeTypeMap;
}
}
V1ServiceList.discriminator = undefined;
V1ServiceList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1ServiceList = V1ServiceList;
/**
* ServicePort contains information on service's port.
*/
class V1ServicePort {
static getAttributeTypeMap() {
return V1ServicePort.attributeTypeMap;
}
}
V1ServicePort.discriminator = undefined;
V1ServicePort.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "nodePort",
"baseName": "nodePort",
"type": "number"
},
{
"name": "port",
"baseName": "port",
"type": "number"
},
{
"name": "protocol",
"baseName": "protocol",
"type": "string"
},
{
"name": "targetPort",
"baseName": "targetPort",
"type": "any"
}
];
exports.V1ServicePort = V1ServicePort;
/**
* ServiceReference holds a reference to Service.legacy.k8s.io
*/
class V1ServiceReference {
static getAttributeTypeMap() {
return V1ServiceReference.attributeTypeMap;
}
}
V1ServiceReference.discriminator = undefined;
V1ServiceReference.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
}
];
exports.V1ServiceReference = V1ServiceReference;
/**
* ServiceSpec describes the attributes that a user creates on a service.
*/
class V1ServiceSpec {
static getAttributeTypeMap() {
return V1ServiceSpec.attributeTypeMap;
}
}
V1ServiceSpec.discriminator = undefined;
V1ServiceSpec.attributeTypeMap = [
{
"name": "clusterIP",
"baseName": "clusterIP",
"type": "string"
},
{
"name": "externalIPs",
"baseName": "externalIPs",
"type": "Array"
},
{
"name": "externalName",
"baseName": "externalName",
"type": "string"
},
{
"name": "externalTrafficPolicy",
"baseName": "externalTrafficPolicy",
"type": "string"
},
{
"name": "healthCheckNodePort",
"baseName": "healthCheckNodePort",
"type": "number"
},
{
"name": "loadBalancerIP",
"baseName": "loadBalancerIP",
"type": "string"
},
{
"name": "loadBalancerSourceRanges",
"baseName": "loadBalancerSourceRanges",
"type": "Array"
},
{
"name": "ports",
"baseName": "ports",
"type": "Array"
},
{
"name": "publishNotReadyAddresses",
"baseName": "publishNotReadyAddresses",
"type": "boolean"
},
{
"name": "selector",
"baseName": "selector",
"type": "{ [key: string]: string; }"
},
{
"name": "sessionAffinity",
"baseName": "sessionAffinity",
"type": "string"
},
{
"name": "sessionAffinityConfig",
"baseName": "sessionAffinityConfig",
"type": "V1SessionAffinityConfig"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1ServiceSpec = V1ServiceSpec;
/**
* ServiceStatus represents the current status of a service.
*/
class V1ServiceStatus {
static getAttributeTypeMap() {
return V1ServiceStatus.attributeTypeMap;
}
}
V1ServiceStatus.discriminator = undefined;
V1ServiceStatus.attributeTypeMap = [
{
"name": "loadBalancer",
"baseName": "loadBalancer",
"type": "V1LoadBalancerStatus"
}
];
exports.V1ServiceStatus = V1ServiceStatus;
/**
* SessionAffinityConfig represents the configurations of session affinity.
*/
class V1SessionAffinityConfig {
static getAttributeTypeMap() {
return V1SessionAffinityConfig.attributeTypeMap;
}
}
V1SessionAffinityConfig.discriminator = undefined;
V1SessionAffinityConfig.attributeTypeMap = [
{
"name": "clientIP",
"baseName": "clientIP",
"type": "V1ClientIPConfig"
}
];
exports.V1SessionAffinityConfig = V1SessionAffinityConfig;
/**
* 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.
*/
class V1StatefulSet {
static getAttributeTypeMap() {
return V1StatefulSet.attributeTypeMap;
}
}
V1StatefulSet.discriminator = undefined;
V1StatefulSet.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1StatefulSetSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1StatefulSetStatus"
}
];
exports.V1StatefulSet = V1StatefulSet;
/**
* StatefulSetCondition describes the state of a statefulset at a certain point.
*/
class V1StatefulSetCondition {
static getAttributeTypeMap() {
return V1StatefulSetCondition.attributeTypeMap;
}
}
V1StatefulSetCondition.discriminator = undefined;
V1StatefulSetCondition.attributeTypeMap = [
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1StatefulSetCondition = V1StatefulSetCondition;
/**
* StatefulSetList is a collection of StatefulSets.
*/
class V1StatefulSetList {
static getAttributeTypeMap() {
return V1StatefulSetList.attributeTypeMap;
}
}
V1StatefulSetList.discriminator = undefined;
V1StatefulSetList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1StatefulSetList = V1StatefulSetList;
/**
* A StatefulSetSpec is the specification of a StatefulSet.
*/
class V1StatefulSetSpec {
static getAttributeTypeMap() {
return V1StatefulSetSpec.attributeTypeMap;
}
}
V1StatefulSetSpec.discriminator = undefined;
V1StatefulSetSpec.attributeTypeMap = [
{
"name": "podManagementPolicy",
"baseName": "podManagementPolicy",
"type": "string"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "revisionHistoryLimit",
"baseName": "revisionHistoryLimit",
"type": "number"
},
{
"name": "selector",
"baseName": "selector",
"type": "V1LabelSelector"
},
{
"name": "serviceName",
"baseName": "serviceName",
"type": "string"
},
{
"name": "template",
"baseName": "template",
"type": "V1PodTemplateSpec"
},
{
"name": "updateStrategy",
"baseName": "updateStrategy",
"type": "V1StatefulSetUpdateStrategy"
},
{
"name": "volumeClaimTemplates",
"baseName": "volumeClaimTemplates",
"type": "Array"
}
];
exports.V1StatefulSetSpec = V1StatefulSetSpec;
/**
* StatefulSetStatus represents the current state of a StatefulSet.
*/
class V1StatefulSetStatus {
static getAttributeTypeMap() {
return V1StatefulSetStatus.attributeTypeMap;
}
}
V1StatefulSetStatus.discriminator = undefined;
V1StatefulSetStatus.attributeTypeMap = [
{
"name": "collisionCount",
"baseName": "collisionCount",
"type": "number"
},
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
},
{
"name": "currentReplicas",
"baseName": "currentReplicas",
"type": "number"
},
{
"name": "currentRevision",
"baseName": "currentRevision",
"type": "string"
},
{
"name": "observedGeneration",
"baseName": "observedGeneration",
"type": "number"
},
{
"name": "readyReplicas",
"baseName": "readyReplicas",
"type": "number"
},
{
"name": "replicas",
"baseName": "replicas",
"type": "number"
},
{
"name": "updateRevision",
"baseName": "updateRevision",
"type": "string"
},
{
"name": "updatedReplicas",
"baseName": "updatedReplicas",
"type": "number"
}
];
exports.V1StatefulSetStatus = V1StatefulSetStatus;
/**
* 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.
*/
class V1StatefulSetUpdateStrategy {
static getAttributeTypeMap() {
return V1StatefulSetUpdateStrategy.attributeTypeMap;
}
}
V1StatefulSetUpdateStrategy.discriminator = undefined;
V1StatefulSetUpdateStrategy.attributeTypeMap = [
{
"name": "rollingUpdate",
"baseName": "rollingUpdate",
"type": "V1RollingUpdateStatefulSetStrategy"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1StatefulSetUpdateStrategy = V1StatefulSetUpdateStrategy;
/**
* Status is a return value for calls that don't return other objects.
*/
class V1Status {
static getAttributeTypeMap() {
return V1Status.attributeTypeMap;
}
}
V1Status.discriminator = undefined;
V1Status.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "code",
"baseName": "code",
"type": "number"
},
{
"name": "details",
"baseName": "details",
"type": "V1StatusDetails"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
}
];
exports.V1Status = V1Status;
/**
* StatusCause provides more information about an api.Status failure, including cases when multiple errors are encountered.
*/
class V1StatusCause {
static getAttributeTypeMap() {
return V1StatusCause.attributeTypeMap;
}
}
V1StatusCause.discriminator = undefined;
V1StatusCause.attributeTypeMap = [
{
"name": "field",
"baseName": "field",
"type": "string"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
}
];
exports.V1StatusCause = 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.
*/
class V1StatusDetails {
static getAttributeTypeMap() {
return V1StatusDetails.attributeTypeMap;
}
}
V1StatusDetails.discriminator = undefined;
V1StatusDetails.attributeTypeMap = [
{
"name": "causes",
"baseName": "causes",
"type": "Array"
},
{
"name": "group",
"baseName": "group",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "retryAfterSeconds",
"baseName": "retryAfterSeconds",
"type": "number"
},
{
"name": "uid",
"baseName": "uid",
"type": "string"
}
];
exports.V1StatusDetails = V1StatusDetails;
/**
* 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.
*/
class V1StorageClass {
static getAttributeTypeMap() {
return V1StorageClass.attributeTypeMap;
}
}
V1StorageClass.discriminator = undefined;
V1StorageClass.attributeTypeMap = [
{
"name": "allowVolumeExpansion",
"baseName": "allowVolumeExpansion",
"type": "boolean"
},
{
"name": "allowedTopologies",
"baseName": "allowedTopologies",
"type": "Array"
},
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "mountOptions",
"baseName": "mountOptions",
"type": "Array"
},
{
"name": "parameters",
"baseName": "parameters",
"type": "{ [key: string]: string; }"
},
{
"name": "provisioner",
"baseName": "provisioner",
"type": "string"
},
{
"name": "reclaimPolicy",
"baseName": "reclaimPolicy",
"type": "string"
},
{
"name": "volumeBindingMode",
"baseName": "volumeBindingMode",
"type": "string"
}
];
exports.V1StorageClass = V1StorageClass;
/**
* StorageClassList is a collection of storage classes.
*/
class V1StorageClassList {
static getAttributeTypeMap() {
return V1StorageClassList.attributeTypeMap;
}
}
V1StorageClassList.discriminator = undefined;
V1StorageClassList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1StorageClassList = V1StorageClassList;
/**
* Represents a StorageOS persistent volume resource.
*/
class V1StorageOSPersistentVolumeSource {
static getAttributeTypeMap() {
return V1StorageOSPersistentVolumeSource.attributeTypeMap;
}
}
V1StorageOSPersistentVolumeSource.discriminator = undefined;
V1StorageOSPersistentVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1ObjectReference"
},
{
"name": "volumeName",
"baseName": "volumeName",
"type": "string"
},
{
"name": "volumeNamespace",
"baseName": "volumeNamespace",
"type": "string"
}
];
exports.V1StorageOSPersistentVolumeSource = V1StorageOSPersistentVolumeSource;
/**
* Represents a StorageOS persistent volume resource.
*/
class V1StorageOSVolumeSource {
static getAttributeTypeMap() {
return V1StorageOSVolumeSource.attributeTypeMap;
}
}
V1StorageOSVolumeSource.discriminator = undefined;
V1StorageOSVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "secretRef",
"baseName": "secretRef",
"type": "V1LocalObjectReference"
},
{
"name": "volumeName",
"baseName": "volumeName",
"type": "string"
},
{
"name": "volumeNamespace",
"baseName": "volumeNamespace",
"type": "string"
}
];
exports.V1StorageOSVolumeSource = V1StorageOSVolumeSource;
/**
* 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.
*/
class V1Subject {
static getAttributeTypeMap() {
return V1Subject.attributeTypeMap;
}
}
V1Subject.discriminator = undefined;
V1Subject.attributeTypeMap = [
{
"name": "apiGroup",
"baseName": "apiGroup",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
}
];
exports.V1Subject = V1Subject;
/**
* SubjectAccessReview checks whether or not a user or group can perform an action.
*/
class V1SubjectAccessReview {
static getAttributeTypeMap() {
return V1SubjectAccessReview.attributeTypeMap;
}
}
V1SubjectAccessReview.discriminator = undefined;
V1SubjectAccessReview.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1SubjectAccessReviewSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1SubjectAccessReviewStatus"
}
];
exports.V1SubjectAccessReview = V1SubjectAccessReview;
/**
* SubjectAccessReviewSpec is a description of the access request. Exactly one of ResourceAuthorizationAttributes and NonResourceAuthorizationAttributes must be set
*/
class V1SubjectAccessReviewSpec {
static getAttributeTypeMap() {
return V1SubjectAccessReviewSpec.attributeTypeMap;
}
}
V1SubjectAccessReviewSpec.discriminator = undefined;
V1SubjectAccessReviewSpec.attributeTypeMap = [
{
"name": "extra",
"baseName": "extra",
"type": "{ [key: string]: Array; }"
},
{
"name": "groups",
"baseName": "groups",
"type": "Array"
},
{
"name": "nonResourceAttributes",
"baseName": "nonResourceAttributes",
"type": "V1NonResourceAttributes"
},
{
"name": "resourceAttributes",
"baseName": "resourceAttributes",
"type": "V1ResourceAttributes"
},
{
"name": "uid",
"baseName": "uid",
"type": "string"
},
{
"name": "user",
"baseName": "user",
"type": "string"
}
];
exports.V1SubjectAccessReviewSpec = V1SubjectAccessReviewSpec;
/**
* SubjectAccessReviewStatus
*/
class V1SubjectAccessReviewStatus {
static getAttributeTypeMap() {
return V1SubjectAccessReviewStatus.attributeTypeMap;
}
}
V1SubjectAccessReviewStatus.discriminator = undefined;
V1SubjectAccessReviewStatus.attributeTypeMap = [
{
"name": "allowed",
"baseName": "allowed",
"type": "boolean"
},
{
"name": "denied",
"baseName": "denied",
"type": "boolean"
},
{
"name": "evaluationError",
"baseName": "evaluationError",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
}
];
exports.V1SubjectAccessReviewStatus = V1SubjectAccessReviewStatus;
/**
* 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.
*/
class V1SubjectRulesReviewStatus {
static getAttributeTypeMap() {
return V1SubjectRulesReviewStatus.attributeTypeMap;
}
}
V1SubjectRulesReviewStatus.discriminator = undefined;
V1SubjectRulesReviewStatus.attributeTypeMap = [
{
"name": "evaluationError",
"baseName": "evaluationError",
"type": "string"
},
{
"name": "incomplete",
"baseName": "incomplete",
"type": "boolean"
},
{
"name": "nonResourceRules",
"baseName": "nonResourceRules",
"type": "Array"
},
{
"name": "resourceRules",
"baseName": "resourceRules",
"type": "Array"
}
];
exports.V1SubjectRulesReviewStatus = V1SubjectRulesReviewStatus;
/**
* Sysctl defines a kernel parameter to be set
*/
class V1Sysctl {
static getAttributeTypeMap() {
return V1Sysctl.attributeTypeMap;
}
}
V1Sysctl.discriminator = undefined;
V1Sysctl.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "value",
"baseName": "value",
"type": "string"
}
];
exports.V1Sysctl = V1Sysctl;
/**
* TCPSocketAction describes an action based on opening a socket
*/
class V1TCPSocketAction {
static getAttributeTypeMap() {
return V1TCPSocketAction.attributeTypeMap;
}
}
V1TCPSocketAction.discriminator = undefined;
V1TCPSocketAction.attributeTypeMap = [
{
"name": "host",
"baseName": "host",
"type": "string"
},
{
"name": "port",
"baseName": "port",
"type": "any"
}
];
exports.V1TCPSocketAction = V1TCPSocketAction;
/**
* The node this Taint is attached to has the \"effect\" on any pod that does not tolerate the Taint.
*/
class V1Taint {
static getAttributeTypeMap() {
return V1Taint.attributeTypeMap;
}
}
V1Taint.discriminator = undefined;
V1Taint.attributeTypeMap = [
{
"name": "effect",
"baseName": "effect",
"type": "string"
},
{
"name": "key",
"baseName": "key",
"type": "string"
},
{
"name": "timeAdded",
"baseName": "timeAdded",
"type": "Date"
},
{
"name": "value",
"baseName": "value",
"type": "string"
}
];
exports.V1Taint = V1Taint;
/**
* 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.
*/
class V1TokenReview {
static getAttributeTypeMap() {
return V1TokenReview.attributeTypeMap;
}
}
V1TokenReview.discriminator = undefined;
V1TokenReview.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1TokenReviewSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1TokenReviewStatus"
}
];
exports.V1TokenReview = V1TokenReview;
/**
* TokenReviewSpec is a description of the token authentication request.
*/
class V1TokenReviewSpec {
static getAttributeTypeMap() {
return V1TokenReviewSpec.attributeTypeMap;
}
}
V1TokenReviewSpec.discriminator = undefined;
V1TokenReviewSpec.attributeTypeMap = [
{
"name": "audiences",
"baseName": "audiences",
"type": "Array"
},
{
"name": "token",
"baseName": "token",
"type": "string"
}
];
exports.V1TokenReviewSpec = V1TokenReviewSpec;
/**
* TokenReviewStatus is the result of the token authentication request.
*/
class V1TokenReviewStatus {
static getAttributeTypeMap() {
return V1TokenReviewStatus.attributeTypeMap;
}
}
V1TokenReviewStatus.discriminator = undefined;
V1TokenReviewStatus.attributeTypeMap = [
{
"name": "audiences",
"baseName": "audiences",
"type": "Array"
},
{
"name": "authenticated",
"baseName": "authenticated",
"type": "boolean"
},
{
"name": "error",
"baseName": "error",
"type": "string"
},
{
"name": "user",
"baseName": "user",
"type": "V1UserInfo"
}
];
exports.V1TokenReviewStatus = V1TokenReviewStatus;
/**
* The pod this Toleration is attached to tolerates any taint that matches the triple using the matching operator .
*/
class V1Toleration {
static getAttributeTypeMap() {
return V1Toleration.attributeTypeMap;
}
}
V1Toleration.discriminator = undefined;
V1Toleration.attributeTypeMap = [
{
"name": "effect",
"baseName": "effect",
"type": "string"
},
{
"name": "key",
"baseName": "key",
"type": "string"
},
{
"name": "operator",
"baseName": "operator",
"type": "string"
},
{
"name": "tolerationSeconds",
"baseName": "tolerationSeconds",
"type": "number"
},
{
"name": "value",
"baseName": "value",
"type": "string"
}
];
exports.V1Toleration = V1Toleration;
/**
* A topology selector requirement is a selector that matches given label. This is an alpha feature and may change in the future.
*/
class V1TopologySelectorLabelRequirement {
static getAttributeTypeMap() {
return V1TopologySelectorLabelRequirement.attributeTypeMap;
}
}
V1TopologySelectorLabelRequirement.discriminator = undefined;
V1TopologySelectorLabelRequirement.attributeTypeMap = [
{
"name": "key",
"baseName": "key",
"type": "string"
},
{
"name": "values",
"baseName": "values",
"type": "Array"
}
];
exports.V1TopologySelectorLabelRequirement = 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.
*/
class V1TopologySelectorTerm {
static getAttributeTypeMap() {
return V1TopologySelectorTerm.attributeTypeMap;
}
}
V1TopologySelectorTerm.discriminator = undefined;
V1TopologySelectorTerm.attributeTypeMap = [
{
"name": "matchLabelExpressions",
"baseName": "matchLabelExpressions",
"type": "Array"
}
];
exports.V1TopologySelectorTerm = V1TopologySelectorTerm;
/**
* TypedLocalObjectReference contains enough information to let you locate the typed referenced object inside the same namespace.
*/
class V1TypedLocalObjectReference {
static getAttributeTypeMap() {
return V1TypedLocalObjectReference.attributeTypeMap;
}
}
V1TypedLocalObjectReference.discriminator = undefined;
V1TypedLocalObjectReference.attributeTypeMap = [
{
"name": "apiGroup",
"baseName": "apiGroup",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
}
];
exports.V1TypedLocalObjectReference = V1TypedLocalObjectReference;
/**
* UserInfo holds the information about the user needed to implement the user.Info interface.
*/
class V1UserInfo {
static getAttributeTypeMap() {
return V1UserInfo.attributeTypeMap;
}
}
V1UserInfo.discriminator = undefined;
V1UserInfo.attributeTypeMap = [
{
"name": "extra",
"baseName": "extra",
"type": "{ [key: string]: Array; }"
},
{
"name": "groups",
"baseName": "groups",
"type": "Array"
},
{
"name": "uid",
"baseName": "uid",
"type": "string"
},
{
"name": "username",
"baseName": "username",
"type": "string"
}
];
exports.V1UserInfo = V1UserInfo;
/**
* Volume represents a named volume in a pod that may be accessed by any container in the pod.
*/
class V1Volume {
static getAttributeTypeMap() {
return V1Volume.attributeTypeMap;
}
}
V1Volume.discriminator = undefined;
V1Volume.attributeTypeMap = [
{
"name": "awsElasticBlockStore",
"baseName": "awsElasticBlockStore",
"type": "V1AWSElasticBlockStoreVolumeSource"
},
{
"name": "azureDisk",
"baseName": "azureDisk",
"type": "V1AzureDiskVolumeSource"
},
{
"name": "azureFile",
"baseName": "azureFile",
"type": "V1AzureFileVolumeSource"
},
{
"name": "cephfs",
"baseName": "cephfs",
"type": "V1CephFSVolumeSource"
},
{
"name": "cinder",
"baseName": "cinder",
"type": "V1CinderVolumeSource"
},
{
"name": "configMap",
"baseName": "configMap",
"type": "V1ConfigMapVolumeSource"
},
{
"name": "downwardAPI",
"baseName": "downwardAPI",
"type": "V1DownwardAPIVolumeSource"
},
{
"name": "emptyDir",
"baseName": "emptyDir",
"type": "V1EmptyDirVolumeSource"
},
{
"name": "fc",
"baseName": "fc",
"type": "V1FCVolumeSource"
},
{
"name": "flexVolume",
"baseName": "flexVolume",
"type": "V1FlexVolumeSource"
},
{
"name": "flocker",
"baseName": "flocker",
"type": "V1FlockerVolumeSource"
},
{
"name": "gcePersistentDisk",
"baseName": "gcePersistentDisk",
"type": "V1GCEPersistentDiskVolumeSource"
},
{
"name": "gitRepo",
"baseName": "gitRepo",
"type": "V1GitRepoVolumeSource"
},
{
"name": "glusterfs",
"baseName": "glusterfs",
"type": "V1GlusterfsVolumeSource"
},
{
"name": "hostPath",
"baseName": "hostPath",
"type": "V1HostPathVolumeSource"
},
{
"name": "iscsi",
"baseName": "iscsi",
"type": "V1ISCSIVolumeSource"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "nfs",
"baseName": "nfs",
"type": "V1NFSVolumeSource"
},
{
"name": "persistentVolumeClaim",
"baseName": "persistentVolumeClaim",
"type": "V1PersistentVolumeClaimVolumeSource"
},
{
"name": "photonPersistentDisk",
"baseName": "photonPersistentDisk",
"type": "V1PhotonPersistentDiskVolumeSource"
},
{
"name": "portworxVolume",
"baseName": "portworxVolume",
"type": "V1PortworxVolumeSource"
},
{
"name": "projected",
"baseName": "projected",
"type": "V1ProjectedVolumeSource"
},
{
"name": "quobyte",
"baseName": "quobyte",
"type": "V1QuobyteVolumeSource"
},
{
"name": "rbd",
"baseName": "rbd",
"type": "V1RBDVolumeSource"
},
{
"name": "scaleIO",
"baseName": "scaleIO",
"type": "V1ScaleIOVolumeSource"
},
{
"name": "secret",
"baseName": "secret",
"type": "V1SecretVolumeSource"
},
{
"name": "storageos",
"baseName": "storageos",
"type": "V1StorageOSVolumeSource"
},
{
"name": "vsphereVolume",
"baseName": "vsphereVolume",
"type": "V1VsphereVirtualDiskVolumeSource"
}
];
exports.V1Volume = V1Volume;
/**
* VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. VolumeAttachment objects are non-namespaced.
*/
class V1VolumeAttachment {
static getAttributeTypeMap() {
return V1VolumeAttachment.attributeTypeMap;
}
}
V1VolumeAttachment.discriminator = undefined;
V1VolumeAttachment.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1VolumeAttachmentSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1VolumeAttachmentStatus"
}
];
exports.V1VolumeAttachment = V1VolumeAttachment;
/**
* VolumeAttachmentList is a collection of VolumeAttachment objects.
*/
class V1VolumeAttachmentList {
static getAttributeTypeMap() {
return V1VolumeAttachmentList.attributeTypeMap;
}
}
V1VolumeAttachmentList.discriminator = undefined;
V1VolumeAttachmentList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1VolumeAttachmentList = V1VolumeAttachmentList;
/**
* 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.
*/
class V1VolumeAttachmentSource {
static getAttributeTypeMap() {
return V1VolumeAttachmentSource.attributeTypeMap;
}
}
V1VolumeAttachmentSource.discriminator = undefined;
V1VolumeAttachmentSource.attributeTypeMap = [
{
"name": "persistentVolumeName",
"baseName": "persistentVolumeName",
"type": "string"
}
];
exports.V1VolumeAttachmentSource = V1VolumeAttachmentSource;
/**
* VolumeAttachmentSpec is the specification of a VolumeAttachment request.
*/
class V1VolumeAttachmentSpec {
static getAttributeTypeMap() {
return V1VolumeAttachmentSpec.attributeTypeMap;
}
}
V1VolumeAttachmentSpec.discriminator = undefined;
V1VolumeAttachmentSpec.attributeTypeMap = [
{
"name": "attacher",
"baseName": "attacher",
"type": "string"
},
{
"name": "nodeName",
"baseName": "nodeName",
"type": "string"
},
{
"name": "source",
"baseName": "source",
"type": "V1VolumeAttachmentSource"
}
];
exports.V1VolumeAttachmentSpec = V1VolumeAttachmentSpec;
/**
* VolumeAttachmentStatus is the status of a VolumeAttachment request.
*/
class V1VolumeAttachmentStatus {
static getAttributeTypeMap() {
return V1VolumeAttachmentStatus.attributeTypeMap;
}
}
V1VolumeAttachmentStatus.discriminator = undefined;
V1VolumeAttachmentStatus.attributeTypeMap = [
{
"name": "attachError",
"baseName": "attachError",
"type": "V1VolumeError"
},
{
"name": "attached",
"baseName": "attached",
"type": "boolean"
},
{
"name": "attachmentMetadata",
"baseName": "attachmentMetadata",
"type": "{ [key: string]: string; }"
},
{
"name": "detachError",
"baseName": "detachError",
"type": "V1VolumeError"
}
];
exports.V1VolumeAttachmentStatus = V1VolumeAttachmentStatus;
/**
* volumeDevice describes a mapping of a raw block device within a container.
*/
class V1VolumeDevice {
static getAttributeTypeMap() {
return V1VolumeDevice.attributeTypeMap;
}
}
V1VolumeDevice.discriminator = undefined;
V1VolumeDevice.attributeTypeMap = [
{
"name": "devicePath",
"baseName": "devicePath",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
}
];
exports.V1VolumeDevice = V1VolumeDevice;
/**
* VolumeError captures an error encountered during a volume operation.
*/
class V1VolumeError {
static getAttributeTypeMap() {
return V1VolumeError.attributeTypeMap;
}
}
V1VolumeError.discriminator = undefined;
V1VolumeError.attributeTypeMap = [
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "time",
"baseName": "time",
"type": "Date"
}
];
exports.V1VolumeError = V1VolumeError;
/**
* VolumeMount describes a mounting of a Volume within a container.
*/
class V1VolumeMount {
static getAttributeTypeMap() {
return V1VolumeMount.attributeTypeMap;
}
}
V1VolumeMount.discriminator = undefined;
V1VolumeMount.attributeTypeMap = [
{
"name": "mountPath",
"baseName": "mountPath",
"type": "string"
},
{
"name": "mountPropagation",
"baseName": "mountPropagation",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "readOnly",
"baseName": "readOnly",
"type": "boolean"
},
{
"name": "subPath",
"baseName": "subPath",
"type": "string"
}
];
exports.V1VolumeMount = V1VolumeMount;
/**
* VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.
*/
class V1VolumeNodeAffinity {
static getAttributeTypeMap() {
return V1VolumeNodeAffinity.attributeTypeMap;
}
}
V1VolumeNodeAffinity.discriminator = undefined;
V1VolumeNodeAffinity.attributeTypeMap = [
{
"name": "required",
"baseName": "required",
"type": "V1NodeSelector"
}
];
exports.V1VolumeNodeAffinity = V1VolumeNodeAffinity;
/**
* Projection that may be projected along with other supported volume types
*/
class V1VolumeProjection {
static getAttributeTypeMap() {
return V1VolumeProjection.attributeTypeMap;
}
}
V1VolumeProjection.discriminator = undefined;
V1VolumeProjection.attributeTypeMap = [
{
"name": "configMap",
"baseName": "configMap",
"type": "V1ConfigMapProjection"
},
{
"name": "downwardAPI",
"baseName": "downwardAPI",
"type": "V1DownwardAPIProjection"
},
{
"name": "secret",
"baseName": "secret",
"type": "V1SecretProjection"
},
{
"name": "serviceAccountToken",
"baseName": "serviceAccountToken",
"type": "V1ServiceAccountTokenProjection"
}
];
exports.V1VolumeProjection = V1VolumeProjection;
/**
* Represents a vSphere volume resource.
*/
class V1VsphereVirtualDiskVolumeSource {
static getAttributeTypeMap() {
return V1VsphereVirtualDiskVolumeSource.attributeTypeMap;
}
}
V1VsphereVirtualDiskVolumeSource.discriminator = undefined;
V1VsphereVirtualDiskVolumeSource.attributeTypeMap = [
{
"name": "fsType",
"baseName": "fsType",
"type": "string"
},
{
"name": "storagePolicyID",
"baseName": "storagePolicyID",
"type": "string"
},
{
"name": "storagePolicyName",
"baseName": "storagePolicyName",
"type": "string"
},
{
"name": "volumePath",
"baseName": "volumePath",
"type": "string"
}
];
exports.V1VsphereVirtualDiskVolumeSource = V1VsphereVirtualDiskVolumeSource;
/**
* Event represents a single event to a watched resource.
*/
class V1WatchEvent {
static getAttributeTypeMap() {
return V1WatchEvent.attributeTypeMap;
}
}
V1WatchEvent.discriminator = undefined;
V1WatchEvent.attributeTypeMap = [
{
"name": "object",
"baseName": "object",
"type": "RuntimeRawExtension"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1WatchEvent = V1WatchEvent;
/**
* The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
*/
class V1WeightedPodAffinityTerm {
static getAttributeTypeMap() {
return V1WeightedPodAffinityTerm.attributeTypeMap;
}
}
V1WeightedPodAffinityTerm.discriminator = undefined;
V1WeightedPodAffinityTerm.attributeTypeMap = [
{
"name": "podAffinityTerm",
"baseName": "podAffinityTerm",
"type": "V1PodAffinityTerm"
},
{
"name": "weight",
"baseName": "weight",
"type": "number"
}
];
exports.V1WeightedPodAffinityTerm = V1WeightedPodAffinityTerm;
/**
* AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole
*/
class V1alpha1AggregationRule {
static getAttributeTypeMap() {
return V1alpha1AggregationRule.attributeTypeMap;
}
}
V1alpha1AggregationRule.discriminator = undefined;
V1alpha1AggregationRule.attributeTypeMap = [
{
"name": "clusterRoleSelectors",
"baseName": "clusterRoleSelectors",
"type": "Array"
}
];
exports.V1alpha1AggregationRule = V1alpha1AggregationRule;
/**
* AuditSink represents a cluster level audit sink
*/
class V1alpha1AuditSink {
static getAttributeTypeMap() {
return V1alpha1AuditSink.attributeTypeMap;
}
}
V1alpha1AuditSink.discriminator = undefined;
V1alpha1AuditSink.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1alpha1AuditSinkSpec"
}
];
exports.V1alpha1AuditSink = V1alpha1AuditSink;
/**
* AuditSinkList is a list of AuditSink items.
*/
class V1alpha1AuditSinkList {
static getAttributeTypeMap() {
return V1alpha1AuditSinkList.attributeTypeMap;
}
}
V1alpha1AuditSinkList.discriminator = undefined;
V1alpha1AuditSinkList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1alpha1AuditSinkList = V1alpha1AuditSinkList;
/**
* AuditSinkSpec holds the spec for the audit sink
*/
class V1alpha1AuditSinkSpec {
static getAttributeTypeMap() {
return V1alpha1AuditSinkSpec.attributeTypeMap;
}
}
V1alpha1AuditSinkSpec.discriminator = undefined;
V1alpha1AuditSinkSpec.attributeTypeMap = [
{
"name": "policy",
"baseName": "policy",
"type": "V1alpha1Policy"
},
{
"name": "webhook",
"baseName": "webhook",
"type": "V1alpha1Webhook"
}
];
exports.V1alpha1AuditSinkSpec = V1alpha1AuditSinkSpec;
/**
* ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding.
*/
class V1alpha1ClusterRole {
static getAttributeTypeMap() {
return V1alpha1ClusterRole.attributeTypeMap;
}
}
V1alpha1ClusterRole.discriminator = undefined;
V1alpha1ClusterRole.attributeTypeMap = [
{
"name": "aggregationRule",
"baseName": "aggregationRule",
"type": "V1alpha1AggregationRule"
},
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "rules",
"baseName": "rules",
"type": "Array"
}
];
exports.V1alpha1ClusterRole = V1alpha1ClusterRole;
/**
* ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject.
*/
class V1alpha1ClusterRoleBinding {
static getAttributeTypeMap() {
return V1alpha1ClusterRoleBinding.attributeTypeMap;
}
}
V1alpha1ClusterRoleBinding.discriminator = undefined;
V1alpha1ClusterRoleBinding.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "roleRef",
"baseName": "roleRef",
"type": "V1alpha1RoleRef"
},
{
"name": "subjects",
"baseName": "subjects",
"type": "Array"
}
];
exports.V1alpha1ClusterRoleBinding = V1alpha1ClusterRoleBinding;
/**
* ClusterRoleBindingList is a collection of ClusterRoleBindings
*/
class V1alpha1ClusterRoleBindingList {
static getAttributeTypeMap() {
return V1alpha1ClusterRoleBindingList.attributeTypeMap;
}
}
V1alpha1ClusterRoleBindingList.discriminator = undefined;
V1alpha1ClusterRoleBindingList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1alpha1ClusterRoleBindingList = V1alpha1ClusterRoleBindingList;
/**
* ClusterRoleList is a collection of ClusterRoles
*/
class V1alpha1ClusterRoleList {
static getAttributeTypeMap() {
return V1alpha1ClusterRoleList.attributeTypeMap;
}
}
V1alpha1ClusterRoleList.discriminator = undefined;
V1alpha1ClusterRoleList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1alpha1ClusterRoleList = V1alpha1ClusterRoleList;
/**
* Initializer describes the name and the failure policy of an initializer, and what resources it applies to.
*/
class V1alpha1Initializer {
static getAttributeTypeMap() {
return V1alpha1Initializer.attributeTypeMap;
}
}
V1alpha1Initializer.discriminator = undefined;
V1alpha1Initializer.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "rules",
"baseName": "rules",
"type": "Array"
}
];
exports.V1alpha1Initializer = V1alpha1Initializer;
/**
* InitializerConfiguration describes the configuration of initializers.
*/
class V1alpha1InitializerConfiguration {
static getAttributeTypeMap() {
return V1alpha1InitializerConfiguration.attributeTypeMap;
}
}
V1alpha1InitializerConfiguration.discriminator = undefined;
V1alpha1InitializerConfiguration.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "initializers",
"baseName": "initializers",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
}
];
exports.V1alpha1InitializerConfiguration = V1alpha1InitializerConfiguration;
/**
* InitializerConfigurationList is a list of InitializerConfiguration.
*/
class V1alpha1InitializerConfigurationList {
static getAttributeTypeMap() {
return V1alpha1InitializerConfigurationList.attributeTypeMap;
}
}
V1alpha1InitializerConfigurationList.discriminator = undefined;
V1alpha1InitializerConfigurationList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1alpha1InitializerConfigurationList = V1alpha1InitializerConfigurationList;
/**
* PodPreset is a policy resource that defines additional runtime requirements for a Pod.
*/
class V1alpha1PodPreset {
static getAttributeTypeMap() {
return V1alpha1PodPreset.attributeTypeMap;
}
}
V1alpha1PodPreset.discriminator = undefined;
V1alpha1PodPreset.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1alpha1PodPresetSpec"
}
];
exports.V1alpha1PodPreset = V1alpha1PodPreset;
/**
* PodPresetList is a list of PodPreset objects.
*/
class V1alpha1PodPresetList {
static getAttributeTypeMap() {
return V1alpha1PodPresetList.attributeTypeMap;
}
}
V1alpha1PodPresetList.discriminator = undefined;
V1alpha1PodPresetList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1alpha1PodPresetList = V1alpha1PodPresetList;
/**
* PodPresetSpec is a description of a pod preset.
*/
class V1alpha1PodPresetSpec {
static getAttributeTypeMap() {
return V1alpha1PodPresetSpec.attributeTypeMap;
}
}
V1alpha1PodPresetSpec.discriminator = undefined;
V1alpha1PodPresetSpec.attributeTypeMap = [
{
"name": "env",
"baseName": "env",
"type": "Array"
},
{
"name": "envFrom",
"baseName": "envFrom",
"type": "Array"
},
{
"name": "selector",
"baseName": "selector",
"type": "V1LabelSelector"
},
{
"name": "volumeMounts",
"baseName": "volumeMounts",
"type": "Array"
},
{
"name": "volumes",
"baseName": "volumes",
"type": "Array"
}
];
exports.V1alpha1PodPresetSpec = V1alpha1PodPresetSpec;
/**
* Policy defines the configuration of how audit events are logged
*/
class V1alpha1Policy {
static getAttributeTypeMap() {
return V1alpha1Policy.attributeTypeMap;
}
}
V1alpha1Policy.discriminator = undefined;
V1alpha1Policy.attributeTypeMap = [
{
"name": "level",
"baseName": "level",
"type": "string"
},
{
"name": "stages",
"baseName": "stages",
"type": "Array"
}
];
exports.V1alpha1Policy = V1alpha1Policy;
/**
* 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.
*/
class V1alpha1PolicyRule {
static getAttributeTypeMap() {
return V1alpha1PolicyRule.attributeTypeMap;
}
}
V1alpha1PolicyRule.discriminator = undefined;
V1alpha1PolicyRule.attributeTypeMap = [
{
"name": "apiGroups",
"baseName": "apiGroups",
"type": "Array"
},
{
"name": "nonResourceURLs",
"baseName": "nonResourceURLs",
"type": "Array"
},
{
"name": "resourceNames",
"baseName": "resourceNames",
"type": "Array"
},
{
"name": "resources",
"baseName": "resources",
"type": "Array"
},
{
"name": "verbs",
"baseName": "verbs",
"type": "Array"
}
];
exports.V1alpha1PolicyRule = V1alpha1PolicyRule;
/**
* PriorityClass defines mapping from a priority class name to the priority integer value. The value can be any valid integer.
*/
class V1alpha1PriorityClass {
static getAttributeTypeMap() {
return V1alpha1PriorityClass.attributeTypeMap;
}
}
V1alpha1PriorityClass.discriminator = undefined;
V1alpha1PriorityClass.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "description",
"baseName": "description",
"type": "string"
},
{
"name": "globalDefault",
"baseName": "globalDefault",
"type": "boolean"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "value",
"baseName": "value",
"type": "number"
}
];
exports.V1alpha1PriorityClass = V1alpha1PriorityClass;
/**
* PriorityClassList is a collection of priority classes.
*/
class V1alpha1PriorityClassList {
static getAttributeTypeMap() {
return V1alpha1PriorityClassList.attributeTypeMap;
}
}
V1alpha1PriorityClassList.discriminator = undefined;
V1alpha1PriorityClassList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1alpha1PriorityClassList = V1alpha1PriorityClassList;
/**
* Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding.
*/
class V1alpha1Role {
static getAttributeTypeMap() {
return V1alpha1Role.attributeTypeMap;
}
}
V1alpha1Role.discriminator = undefined;
V1alpha1Role.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "rules",
"baseName": "rules",
"type": "Array"
}
];
exports.V1alpha1Role = V1alpha1Role;
/**
* 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.
*/
class V1alpha1RoleBinding {
static getAttributeTypeMap() {
return V1alpha1RoleBinding.attributeTypeMap;
}
}
V1alpha1RoleBinding.discriminator = undefined;
V1alpha1RoleBinding.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "roleRef",
"baseName": "roleRef",
"type": "V1alpha1RoleRef"
},
{
"name": "subjects",
"baseName": "subjects",
"type": "Array"
}
];
exports.V1alpha1RoleBinding = V1alpha1RoleBinding;
/**
* RoleBindingList is a collection of RoleBindings
*/
class V1alpha1RoleBindingList {
static getAttributeTypeMap() {
return V1alpha1RoleBindingList.attributeTypeMap;
}
}
V1alpha1RoleBindingList.discriminator = undefined;
V1alpha1RoleBindingList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1alpha1RoleBindingList = V1alpha1RoleBindingList;
/**
* RoleList is a collection of Roles
*/
class V1alpha1RoleList {
static getAttributeTypeMap() {
return V1alpha1RoleList.attributeTypeMap;
}
}
V1alpha1RoleList.discriminator = undefined;
V1alpha1RoleList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1alpha1RoleList = V1alpha1RoleList;
/**
* RoleRef contains information that points to the role being used
*/
class V1alpha1RoleRef {
static getAttributeTypeMap() {
return V1alpha1RoleRef.attributeTypeMap;
}
}
V1alpha1RoleRef.discriminator = undefined;
V1alpha1RoleRef.attributeTypeMap = [
{
"name": "apiGroup",
"baseName": "apiGroup",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
}
];
exports.V1alpha1RoleRef = V1alpha1RoleRef;
/**
* Rule is a tuple of APIGroups, APIVersion, and Resources.It is recommended to make sure that all the tuple expansions are valid.
*/
class V1alpha1Rule {
static getAttributeTypeMap() {
return V1alpha1Rule.attributeTypeMap;
}
}
V1alpha1Rule.discriminator = undefined;
V1alpha1Rule.attributeTypeMap = [
{
"name": "apiGroups",
"baseName": "apiGroups",
"type": "Array"
},
{
"name": "apiVersions",
"baseName": "apiVersions",
"type": "Array"
},
{
"name": "resources",
"baseName": "resources",
"type": "Array"
}
];
exports.V1alpha1Rule = V1alpha1Rule;
/**
* ServiceReference holds a reference to Service.legacy.k8s.io
*/
class V1alpha1ServiceReference {
static getAttributeTypeMap() {
return V1alpha1ServiceReference.attributeTypeMap;
}
}
V1alpha1ServiceReference.discriminator = undefined;
V1alpha1ServiceReference.attributeTypeMap = [
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
},
{
"name": "path",
"baseName": "path",
"type": "string"
}
];
exports.V1alpha1ServiceReference = V1alpha1ServiceReference;
/**
* 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.
*/
class V1alpha1Subject {
static getAttributeTypeMap() {
return V1alpha1Subject.attributeTypeMap;
}
}
V1alpha1Subject.discriminator = undefined;
V1alpha1Subject.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "name",
"baseName": "name",
"type": "string"
},
{
"name": "namespace",
"baseName": "namespace",
"type": "string"
}
];
exports.V1alpha1Subject = V1alpha1Subject;
/**
* VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node. VolumeAttachment objects are non-namespaced.
*/
class V1alpha1VolumeAttachment {
static getAttributeTypeMap() {
return V1alpha1VolumeAttachment.attributeTypeMap;
}
}
V1alpha1VolumeAttachment.discriminator = undefined;
V1alpha1VolumeAttachment.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1alpha1VolumeAttachmentSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1alpha1VolumeAttachmentStatus"
}
];
exports.V1alpha1VolumeAttachment = V1alpha1VolumeAttachment;
/**
* VolumeAttachmentList is a collection of VolumeAttachment objects.
*/
class V1alpha1VolumeAttachmentList {
static getAttributeTypeMap() {
return V1alpha1VolumeAttachmentList.attributeTypeMap;
}
}
V1alpha1VolumeAttachmentList.discriminator = undefined;
V1alpha1VolumeAttachmentList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1alpha1VolumeAttachmentList = V1alpha1VolumeAttachmentList;
/**
* 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.
*/
class V1alpha1VolumeAttachmentSource {
static getAttributeTypeMap() {
return V1alpha1VolumeAttachmentSource.attributeTypeMap;
}
}
V1alpha1VolumeAttachmentSource.discriminator = undefined;
V1alpha1VolumeAttachmentSource.attributeTypeMap = [
{
"name": "persistentVolumeName",
"baseName": "persistentVolumeName",
"type": "string"
}
];
exports.V1alpha1VolumeAttachmentSource = V1alpha1VolumeAttachmentSource;
/**
* VolumeAttachmentSpec is the specification of a VolumeAttachment request.
*/
class V1alpha1VolumeAttachmentSpec {
static getAttributeTypeMap() {
return V1alpha1VolumeAttachmentSpec.attributeTypeMap;
}
}
V1alpha1VolumeAttachmentSpec.discriminator = undefined;
V1alpha1VolumeAttachmentSpec.attributeTypeMap = [
{
"name": "attacher",
"baseName": "attacher",
"type": "string"
},
{
"name": "nodeName",
"baseName": "nodeName",
"type": "string"
},
{
"name": "source",
"baseName": "source",
"type": "V1alpha1VolumeAttachmentSource"
}
];
exports.V1alpha1VolumeAttachmentSpec = V1alpha1VolumeAttachmentSpec;
/**
* VolumeAttachmentStatus is the status of a VolumeAttachment request.
*/
class V1alpha1VolumeAttachmentStatus {
static getAttributeTypeMap() {
return V1alpha1VolumeAttachmentStatus.attributeTypeMap;
}
}
V1alpha1VolumeAttachmentStatus.discriminator = undefined;
V1alpha1VolumeAttachmentStatus.attributeTypeMap = [
{
"name": "attachError",
"baseName": "attachError",
"type": "V1alpha1VolumeError"
},
{
"name": "attached",
"baseName": "attached",
"type": "boolean"
},
{
"name": "attachmentMetadata",
"baseName": "attachmentMetadata",
"type": "{ [key: string]: string; }"
},
{
"name": "detachError",
"baseName": "detachError",
"type": "V1alpha1VolumeError"
}
];
exports.V1alpha1VolumeAttachmentStatus = V1alpha1VolumeAttachmentStatus;
/**
* VolumeError captures an error encountered during a volume operation.
*/
class V1alpha1VolumeError {
static getAttributeTypeMap() {
return V1alpha1VolumeError.attributeTypeMap;
}
}
V1alpha1VolumeError.discriminator = undefined;
V1alpha1VolumeError.attributeTypeMap = [
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "time",
"baseName": "time",
"type": "Date"
}
];
exports.V1alpha1VolumeError = V1alpha1VolumeError;
/**
* Webhook holds the configuration of the webhook
*/
class V1alpha1Webhook {
static getAttributeTypeMap() {
return V1alpha1Webhook.attributeTypeMap;
}
}
V1alpha1Webhook.discriminator = undefined;
V1alpha1Webhook.attributeTypeMap = [
{
"name": "clientConfig",
"baseName": "clientConfig",
"type": "V1alpha1WebhookClientConfig"
},
{
"name": "throttle",
"baseName": "throttle",
"type": "V1alpha1WebhookThrottleConfig"
}
];
exports.V1alpha1Webhook = V1alpha1Webhook;
/**
* WebhookClientConfig contains the information to make a connection with the webhook
*/
class V1alpha1WebhookClientConfig {
static getAttributeTypeMap() {
return V1alpha1WebhookClientConfig.attributeTypeMap;
}
}
V1alpha1WebhookClientConfig.discriminator = undefined;
V1alpha1WebhookClientConfig.attributeTypeMap = [
{
"name": "caBundle",
"baseName": "caBundle",
"type": "string"
},
{
"name": "service",
"baseName": "service",
"type": "V1alpha1ServiceReference"
},
{
"name": "url",
"baseName": "url",
"type": "string"
}
];
exports.V1alpha1WebhookClientConfig = V1alpha1WebhookClientConfig;
/**
* WebhookThrottleConfig holds the configuration for throttling events
*/
class V1alpha1WebhookThrottleConfig {
static getAttributeTypeMap() {
return V1alpha1WebhookThrottleConfig.attributeTypeMap;
}
}
V1alpha1WebhookThrottleConfig.discriminator = undefined;
V1alpha1WebhookThrottleConfig.attributeTypeMap = [
{
"name": "burst",
"baseName": "burst",
"type": "number"
},
{
"name": "qps",
"baseName": "qps",
"type": "number"
}
];
exports.V1alpha1WebhookThrottleConfig = V1alpha1WebhookThrottleConfig;
/**
* APIService represents a server for a particular GroupVersion. Name must be \"version.group\".
*/
class V1beta1APIService {
static getAttributeTypeMap() {
return V1beta1APIService.attributeTypeMap;
}
}
V1beta1APIService.discriminator = undefined;
V1beta1APIService.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1beta1APIServiceSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1beta1APIServiceStatus"
}
];
exports.V1beta1APIService = V1beta1APIService;
class V1beta1APIServiceCondition {
static getAttributeTypeMap() {
return V1beta1APIServiceCondition.attributeTypeMap;
}
}
V1beta1APIServiceCondition.discriminator = undefined;
V1beta1APIServiceCondition.attributeTypeMap = [
{
"name": "lastTransitionTime",
"baseName": "lastTransitionTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "status",
"baseName": "status",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1beta1APIServiceCondition = V1beta1APIServiceCondition;
/**
* APIServiceList is a list of APIService objects.
*/
class V1beta1APIServiceList {
static getAttributeTypeMap() {
return V1beta1APIServiceList.attributeTypeMap;
}
}
V1beta1APIServiceList.discriminator = undefined;
V1beta1APIServiceList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1beta1APIServiceList = V1beta1APIServiceList;
/**
* APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification.
*/
class V1beta1APIServiceSpec {
static getAttributeTypeMap() {
return V1beta1APIServiceSpec.attributeTypeMap;
}
}
V1beta1APIServiceSpec.discriminator = undefined;
V1beta1APIServiceSpec.attributeTypeMap = [
{
"name": "caBundle",
"baseName": "caBundle",
"type": "string"
},
{
"name": "group",
"baseName": "group",
"type": "string"
},
{
"name": "groupPriorityMinimum",
"baseName": "groupPriorityMinimum",
"type": "number"
},
{
"name": "insecureSkipTLSVerify",
"baseName": "insecureSkipTLSVerify",
"type": "boolean"
},
{
"name": "service",
"baseName": "service",
"type": "ApiregistrationV1beta1ServiceReference"
},
{
"name": "version",
"baseName": "version",
"type": "string"
},
{
"name": "versionPriority",
"baseName": "versionPriority",
"type": "number"
}
];
exports.V1beta1APIServiceSpec = V1beta1APIServiceSpec;
/**
* APIServiceStatus contains derived information about an API server
*/
class V1beta1APIServiceStatus {
static getAttributeTypeMap() {
return V1beta1APIServiceStatus.attributeTypeMap;
}
}
V1beta1APIServiceStatus.discriminator = undefined;
V1beta1APIServiceStatus.attributeTypeMap = [
{
"name": "conditions",
"baseName": "conditions",
"type": "Array"
}
];
exports.V1beta1APIServiceStatus = V1beta1APIServiceStatus;
/**
* AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole
*/
class V1beta1AggregationRule {
static getAttributeTypeMap() {
return V1beta1AggregationRule.attributeTypeMap;
}
}
V1beta1AggregationRule.discriminator = undefined;
V1beta1AggregationRule.attributeTypeMap = [
{
"name": "clusterRoleSelectors",
"baseName": "clusterRoleSelectors",
"type": "Array"
}
];
exports.V1beta1AggregationRule = V1beta1AggregationRule;
/**
* Describes a certificate signing request
*/
class V1beta1CertificateSigningRequest {
static getAttributeTypeMap() {
return V1beta1CertificateSigningRequest.attributeTypeMap;
}
}
V1beta1CertificateSigningRequest.discriminator = undefined;
V1beta1CertificateSigningRequest.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ObjectMeta"
},
{
"name": "spec",
"baseName": "spec",
"type": "V1beta1CertificateSigningRequestSpec"
},
{
"name": "status",
"baseName": "status",
"type": "V1beta1CertificateSigningRequestStatus"
}
];
exports.V1beta1CertificateSigningRequest = V1beta1CertificateSigningRequest;
class V1beta1CertificateSigningRequestCondition {
static getAttributeTypeMap() {
return V1beta1CertificateSigningRequestCondition.attributeTypeMap;
}
}
V1beta1CertificateSigningRequestCondition.discriminator = undefined;
V1beta1CertificateSigningRequestCondition.attributeTypeMap = [
{
"name": "lastUpdateTime",
"baseName": "lastUpdateTime",
"type": "Date"
},
{
"name": "message",
"baseName": "message",
"type": "string"
},
{
"name": "reason",
"baseName": "reason",
"type": "string"
},
{
"name": "type",
"baseName": "type",
"type": "string"
}
];
exports.V1beta1CertificateSigningRequestCondition = V1beta1CertificateSigningRequestCondition;
class V1beta1CertificateSigningRequestList {
static getAttributeTypeMap() {
return V1beta1CertificateSigningRequestList.attributeTypeMap;
}
}
V1beta1CertificateSigningRequestList.discriminator = undefined;
V1beta1CertificateSigningRequestList.attributeTypeMap = [
{
"name": "apiVersion",
"baseName": "apiVersion",
"type": "string"
},
{
"name": "items",
"baseName": "items",
"type": "Array"
},
{
"name": "kind",
"baseName": "kind",
"type": "string"
},
{
"name": "metadata",
"baseName": "metadata",
"type": "V1ListMeta"
}
];
exports.V1beta1CertificateSigningRequestList = V1beta1CertificateSigningRequestList;
/**
* 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.
*/
class V1beta1CertificateSigningRequestSpec {
static getAttributeTypeMap() {
return V1beta1CertificateSigningRequestSpec.attributeTypeMap;
}
}
V1beta1CertificateSigningRequestSpec.discriminator = undefined;
V1beta1CertificateSigningRequestSpec.attributeTypeMap = [
{
"name": "extra",
"baseName": "extra",
"type": "{ [key: string]: Array; }"
},
{
"name": "groups",
"baseName": "groups",
"type": "Array