tribufu/proxmox-ve-openapi
1
0
Fork 0
mirror of https://github.com/tribufu/proxmox-ve-openapi synced 2026-05-06 07:07:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Update project

Browse source
This commit is contained in:
Guilherme Werner 2025-12-16 18:30:32 -03:00
parent ca7f0b65d9
commit 82d19b6305
6 changed files with 112869 additions and 71873 deletions
Download patch file Download diff file Expand all files Collapse all files

12
.editorconfig Normal file
View file

@ -0,0 +1,12 @@
root = true
[*]
end_of_line = lf
indent_style = space
indent_size = 4
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
[*.md]
trim_trailing_whitespace = false

291
build/generator.js
View file

@ -1,197 +1,236 @@
const pveapi = require('./source') const pveapi = require("./source");
const yaml = require('js-yaml') const yaml = require("js-yaml");
const paths = {} const paths = {};
const models = {} const models = {};
const responses = {} const responses = {};
const tags = [] const tags = [];
const capitalizeFirst = (str) => str.charAt(0).toUpperCase() + str.slice(1) const capitalizeFirst = (str) => str.charAt(0).toUpperCase() + str.slice(1);
function generateOpId(method, path){ function generateOpId(method, path) {
let operation = path.split("/").map(capitalizeFirst).join('').replace(/[\-\_]/g, '') let operation = path
.split("/")
.map(capitalizeFirst)
.join("")
.replace(/[\-\_]/g, "");
operation = operation.replace(/\{[a-z]*\}/g, 'Single') operation = operation.replace(/\{[a-z]*\}/g, "Single");
const prefix = (() => { const prefix = (() => {
switch (method) { switch (method) {
case "post": case "post":
return "create" return "create";
case "put": case "put":
return "update" return "update";
case "patch": case "patch":
return "update" return "update";
default: default:
return method return method;
} }
})() })();
return prefix + operation return prefix + operation;
} }
const mapping = require('./mapping') const mapping = require("./mapping");
function filterSchema(p){ function filterSchema(p) {
const schema = { const schema = {
type: p.type type: p.type,
};
if (p.items) schema.items = filterSchema(p.items);
if (p.properties) {
schema.properties = {};
Object.keys(p.properties).forEach(
(name) =>
(schema.properties[name] = filterSchema(p.properties[name]))
);
} }
if(p.items) return schema;
schema.items = filterSchema(p.items)
if(p.properties){
schema.properties = {}
Object.keys(p.properties).forEach(name => schema.properties[name] = filterSchema(p.properties[name]))
}
return schema
} }
function buildResponseSchema(source){ function buildResponseSchema(source) {
const schema = { type: source.type || 'string', description: source.description || '' } const schema = {
if(schema.type === 'boolean') type: source.type || "string",
schema.type = 'integer' description: source.description || "",
if(schema.type === 'null') };
schema.type = 'string' if (schema.type === "boolean") schema.type = "integer";
if(source.type === 'array' && source.items) if (schema.type === "integer") schema.type = "int64";
schema.items = buildResponseSchema(source.items) if (schema.type === "null") schema.type = "string";
if(source.type === 'object' && source.properties){ if (source.type === "array" && source.items)
schema.properties = {} schema.items = buildResponseSchema(source.items);
Object.keys(source.properties || {}).forEach(k => { if (source.type === "object" && source.properties) {
if(k.endsWith('[n]')){ schema.properties = {};
const nk = k.substr(0, k.length-3) Object.keys(source.properties || {}).forEach((k) => {
for(let i=0; i<30; i++){ if (k.endsWith("[n]")) {
schema.properties[nk+i] = buildResponseSchema(source.properties[k]) const nk = k.substr(0, k.length - 3);
for (let i = 0; i < 30; i++) {
schema.properties[nk + i] = buildResponseSchema(
source.properties[k]
);
} }
}else{ } else {
schema.properties[k] = buildResponseSchema(source.properties[k]) schema.properties[k] = buildResponseSchema(
source.properties[k]
);
} }
}) });
} }
return schema return schema;
} }
function parseInfo(path, method, info){ function parseInfo(path, method, info) {
let id = generateOpId(method, path); let id = generateOpId(method, path);
id = mapping[id] || id id = mapping[id] || id;
const sourceProperties = (info.parameters && info.parameters.properties) ? Object.keys(info.parameters.properties).map(k => ({ name: k, ...info.parameters.properties[k] })) : [] const sourceProperties =
info.parameters && info.parameters.properties
? Object.keys(info.parameters.properties).map((k) => ({
name: k,
...info.parameters.properties[k],
}))
: [];
const properties = [] const properties = [];
sourceProperties.forEach(p => { sourceProperties.forEach((p) => {
if(p.name.endsWith('[n]')){ if (p.name.endsWith("[n]")) {
const nk = p.name.substr(0, p.name.length-3); const nk = p.name.substr(0, p.name.length - 3);
for(let i=0; i<30; i++){ for (let i = 0; i < 30; i++) {
properties.push({ ...JSON.parse(JSON.stringify(p)), name: nk+i }) properties.push({
...JSON.parse(JSON.stringify(p)),
name: nk + i,
});
} }
}else{ } else {
properties.push(p) properties.push(p);
} }
}); });
const requestName = capitalizeFirst(id) + 'Request' const requestName = capitalizeFirst(id) + "Request";
const responseName = capitalizeFirst(id) + 'Response' const responseName = capitalizeFirst(id) + "Response";
paths[path][method] = { paths[path][method] = {
operationId: id, operationId: id,
summary: id, summary: id,
description: info.description || id, description: info.description || id,
tags: [path.substr(1).split('/')[0]], tags: [path.substr(1).split("/")[0]],
parameters: properties.filter(p => path.includes('{'+p.name+'}')).map(p => ({ name: p.name, in: 'path', required: true, description: p.name, schema: { type: p.type } })), parameters: properties
.filter((p) => path.includes("{" + p.name + "}"))
.map((p) => ({
name: p.name,
in: "path",
required: true,
description: p.name,
schema: { type: p.type },
})),
responses: { responses: {
'200': { 200: {
$ref: '#/components/responses/'+responseName $ref: "#/components/responses/" + responseName,
} },
} },
} };
paths[path][method].tags.forEach(t => { paths[path][method].tags.forEach((t) => {
if(!tags.includes(t)) if (!tags.includes(t)) tags.push(t);
tags.push(t) });
})
responses[responseName] = { responses[responseName] = {
description: responseName, description: responseName,
content: { content: {
'application/json': { "application/json": {
schema: { schema: {
type: 'object', type: "object",
properties: { properties: {
errors: { errors: {
type: 'array', type: "array",
items: { items: {
type: 'string' type: "string",
} },
}, },
data: buildResponseSchema(info.returns) data: buildResponseSchema(info.returns),
} },
} },
} },
} },
} };
if(method === 'post' || method === 'put'){ if (method === "post" || method === "put") {
models[requestName] = { models[requestName] = {
title: requestName, title: requestName,
type: 'object', type: "object",
properties: {}, properties: {},
required: [] required: [],
} };
properties.filter(p => !path.includes('{'+p.name+'}')).forEach(p => { properties
models[requestName].properties[p.name] = filterSchema(p) .filter((p) => !path.includes("{" + p.name + "}"))
if(p.optional !== 1){ .forEach((p) => {
models[requestName].required.push(p.name) models[requestName].properties[p.name] = filterSchema(p);
} if (p.optional !== 1) {
}) models[requestName].required.push(p.name);
if(models[requestName].required.length < 1) }
delete models[requestName].required });
if (models[requestName].required.length < 1)
delete models[requestName].required;
paths[path][method].requestBody = { paths[path][method].requestBody = {
content: { content: {
'application/json': { "application/json": {
schema: { schema: {
$ref: '#/components/schemas/'+requestName $ref: "#/components/schemas/" + requestName,
} },
} },
} },
} };
}else{ } else {
properties.filter(p => !path.includes('{'+p.name+'}')).map(p => ({ name: p.name, in: 'query', required: p.optional !== 1, description: p.name, schema: { type: p.type } })) properties
.filter((p) => !path.includes("{" + p.name + "}"))
.map((p) => ({
name: p.name,
in: "query",
required: p.optional !== 1,
description: p.name,
schema: { type: p.type },
}));
} }
} }
function parsePath(source){ function parsePath(source) {
if(source.info && Object.keys(source.info).length > 0){ if (source.info && Object.keys(source.info).length > 0) {
paths[source.path] = {} paths[source.path] = {};
Object.keys(source.info).forEach(method => parseInfo(source.path, method.toLowerCase(), source.info[method])) Object.keys(source.info).forEach((method) =>
parseInfo(source.path, method.toLowerCase(), source.info[method])
);
} }
if(source.children) if (source.children) source.children.forEach(parsePath);
source.children.forEach(parsePath)
} }
pveapi.forEach(parsePath) pveapi.forEach(parsePath);
const spec = { const spec = {
openapi: '3.0.0', openapi: "3.0.0",
info: { info: {
title: 'ProxMox VE API', title: "ProxMox VE API",
version: '2.0', version: "2.0",
description: 'ProxMox VE API', description: "ProxMox VE API",
contact: { contact: {
name: 'LUMASERV Support Team', name: "LUMASERV Support Team",
email: 'support@lumaserv.com' email: "support@lumaserv.com",
} },
}, },
servers: [ servers: [
{ {
description: 'local', description: "local",
url: 'https://cluster.local:8006/api2/json' url: "https://cluster.local:8006/api2/json",
} },
], ],
tags: tags.map(t => ({ name: t })), tags: tags.map((t) => ({ name: t })),
paths: paths, paths: paths,
components: { components: {
schemas: models, schemas: models,
responses: responses responses: responses,
} },
} };
const fs = require('fs') const fs = require("fs");
fs.writeFileSync('../reference/spec.v2.yaml', yaml.safeDump(spec)) fs.writeFileSync("../reference/spec.v2.yaml", yaml.safeDump(spec));

216
build/mapping.js
View file

@ -1,108 +1,110 @@
module.exports = { module.exports = {
getNodesSingleQemu: 'getVMs', getNodesSingleQemu: "getVMs",
createNodesSingleQemu: 'createVM', createNodesSingleQemu: "createVM",
getNodesSingleQemuSingle: 'getVM', getNodesSingleQemuSingle: "getVM",
deleteNodesSingleQemuSingle: 'deleteVM', deleteNodesSingleQemuSingle: "deleteVM",
getNodesSingleQemuSingleFirewall: 'getVMFirewall', getNodesSingleQemuSingleFirewall: "getVMFirewall",
getNodesSingleQemuSingleFirewallRules: 'getVMFirewallRules', getNodesSingleQemuSingleFirewallRules: "getVMFirewallRules",
createNodesSingleQemuSingleFirewallRules: 'createVMFirewallRule', createNodesSingleQemuSingleFirewallRules: "createVMFirewallRule",
getNodesSingleQemuSingleFirewallRulesSingle: 'getVMFirewallRule', getNodesSingleQemuSingleFirewallRulesSingle: "getVMFirewallRule",
updateNodesSingleQemuSingleFirewallRulesSingle: 'updateVMFirewallRule', updateNodesSingleQemuSingleFirewallRulesSingle: "updateVMFirewallRule",
deleteNodesSingleQemuSingleFirewallRulesSingle: 'deleteVMFirewallRule', deleteNodesSingleQemuSingleFirewallRulesSingle: "deleteVMFirewallRule",
getNodesSingleQemuSingleFirewallIpset: 'getVMFirewallIPSets', getNodesSingleQemuSingleFirewallIpset: "getVMFirewallIPSets",
createNodesSingleQemuSingleFirewallIpset: 'createVMFirewallIPSet', createNodesSingleQemuSingleFirewallIpset: "createVMFirewallIPSet",
getNodesSingleQemuSingleFirewallIpsetSingle: 'getVMFirewallIPSet', getNodesSingleQemuSingleFirewallIpsetSingle: "getVMFirewallIPSet",
createNodesSingleQemuSingleFirewallIpsetSingle: 'addVMFirewallIPSetIP', createNodesSingleQemuSingleFirewallIpsetSingle: "addVMFirewallIPSetIP",
deleteNodesSingleQemuSingleFirewallIpsetSingle: 'deleteVMFirewallIPSet', deleteNodesSingleQemuSingleFirewallIpsetSingle: "deleteVMFirewallIPSet",
getNodesSingleQemuSingleFirewallIpsetSingleSingle: 'getVMFirewallIPSetIP', getNodesSingleQemuSingleFirewallIpsetSingleSingle: "getVMFirewallIPSetIP",
updateNodesSingleQemuSingleFirewallIpsetSingleSingle: 'updateVMFirewallIPSetIP', updateNodesSingleQemuSingleFirewallIpsetSingleSingle:
deleteNodesSingleQemuSingleFirewallIpsetSingleSingle: 'removeVMFirewallIPSetIP', "updateVMFirewallIPSetIP",
getNodesSingleQemuSingleFirewallOptions: 'getVMFirewallOptions', deleteNodesSingleQemuSingleFirewallIpsetSingleSingle:
updateNodesSingleQemuSingleFirewallOptions: 'updateVMFirewallOptions', "removeVMFirewallIPSetIP",
getNodesSingleQemuSingleRrd: 'getVMRRD', getNodesSingleQemuSingleFirewallOptions: "getVMFirewallOptions",
getNodesSingleQemuSingleRrddata: 'getVMRRDData', updateNodesSingleQemuSingleFirewallOptions: "updateVMFirewallOptions",
getNodesSingleQemuSingleConfig: 'getVMConfig', getNodesSingleQemuSingleRrd: "getVMRRD",
createNodesSingleQemuSingleConfig: 'updateVMConfig', getNodesSingleQemuSingleRrddata: "getVMRRDData",
updateNodesSingleQemuSingleConfig: 'updateVMConfigSync', getNodesSingleQemuSingleConfig: "getVMConfig",
getNodesSingleQemuSinglePending: 'getVMConfigPending', createNodesSingleQemuSingleConfig: "updateVMConfig",
updateNodesSingleQemuSingleUnlink: 'unlinkVMDiskImages', updateNodesSingleQemuSingleConfig: "updateVMConfigSync",
getNodesSingleQemuSingleStatus: 'getVMStatus', getNodesSingleQemuSinglePending: "getVMConfigPending",
getNodesSingleQemuSingleStatusCurrent: 'getCurrentVMStatus', updateNodesSingleQemuSingleUnlink: "unlinkVMDiskImages",
createNodesSingleQemuSingleStatusStart: 'startVM', getNodesSingleQemuSingleStatus: "getVMStatus",
createNodesSingleQemuSingleStatusStop: 'stopVM', getNodesSingleQemuSingleStatusCurrent: "getCurrentVMStatus",
createNodesSingleQemuSingleStatusReset: 'resetVM', createNodesSingleQemuSingleStatusStart: "startVM",
createNodesSingleQemuSingleStatusShutdown: 'shutdownVM', createNodesSingleQemuSingleStatusStop: "stopVM",
createNodesSingleQemuSingleStatusReboot: 'rebootVM', createNodesSingleQemuSingleStatusReset: "resetVM",
createNodesSingleQemuSingleStatusSuspend: 'suspendVM', createNodesSingleQemuSingleStatusShutdown: "shutdownVM",
createNodesSingleQemuSingleStatusResume: 'resumeVM', createNodesSingleQemuSingleStatusReboot: "rebootVM",
createNodesSingleQemuSingleClone: 'cloneVM', createNodesSingleQemuSingleStatusSuspend: "suspendVM",
getNodesSingleQemuSingleMigrate: 'migrateVM', createNodesSingleQemuSingleStatusResume: "resumeVM",
getNodesSingleQemuSingleSnapshot: 'getVMSnapshots', createNodesSingleQemuSingleClone: "cloneVM",
createNodesSingleQemuSingleSnapshot: 'createVMSnapshot', getNodesSingleQemuSingleMigrate: "migrateVM",
getNodesSingleQemuSingleSnapshotSingle: 'getVMSnapshot', getNodesSingleQemuSingleSnapshot: "getVMSnapshots",
deleteNodesSingleQemuSingleSnapshotSingle: 'deleteVMSnapshot', createNodesSingleQemuSingleSnapshot: "createVMSnapshot",
getNodesSingleQemuSingleSnapshotSingleConfig: 'getVMSnapshotConfig', getNodesSingleQemuSingleSnapshotSingle: "getVMSnapshot",
updateNodesSingleQemuSingleSnapshotSingleConfig: 'updateVMSnapshotConfig', deleteNodesSingleQemuSingleSnapshotSingle: "deleteVMSnapshot",
createNodesSingleQemuSingleSnapshotSingleRollback: 'rollbackVMSnapshot', getNodesSingleQemuSingleSnapshotSingleConfig: "getVMSnapshotConfig",
getNodesSingleFirewall: 'getNodeFirewall', updateNodesSingleQemuSingleSnapshotSingleConfig: "updateVMSnapshotConfig",
getNodesSingleFirewallRules: 'getNodeFirewallRules', createNodesSingleQemuSingleSnapshotSingleRollback: "rollbackVMSnapshot",
createNodesSingleFirewallRules: 'createNodeFirewallRule', getNodesSingleFirewall: "getNodeFirewall",
getNodesSingleFirewallRulesSingle: 'getNodeFirewallRule', getNodesSingleFirewallRules: "getNodeFirewallRules",
updateNodesSingleFirewallRulesSingle: 'updateNodeFirewallRule', createNodesSingleFirewallRules: "createNodeFirewallRule",
deleteNodesSingleFirewallRulesSingle: 'deleteNodeFirewallRule', getNodesSingleFirewallRulesSingle: "getNodeFirewallRule",
getNodesSingleFirewallOptions: 'getNodeFirewallOptions', updateNodesSingleFirewallRulesSingle: "updateNodeFirewallRule",
updateNodesSingleFirewallOptions: 'updateNodeFirewallOptions', deleteNodesSingleFirewallRulesSingle: "deleteNodeFirewallRule",
getNodesSingleSdn: 'getNodeSDN', getNodesSingleFirewallOptions: "getNodeFirewallOptions",
getNodesSingleSdnZones: 'getNodeSDNZones', updateNodesSingleFirewallOptions: "updateNodeFirewallOptions",
getNodesSingleSdnZonesSingle: 'getNodeSDNZone', getNodesSingleSdn: "getNodeSDN",
getNodesSingleSdnZonesSingleContent: 'getNodeSDNZoneContent', getNodesSingleSdnZones: "getNodeSDNZones",
getNodesSingleRrd: 'getNodeRRD', getNodesSingleSdnZonesSingle: "getNodeSDNZone",
getNodesSingleRrddata: 'getNodeRRDData', getNodesSingleSdnZonesSingleContent: "getNodeSDNZoneContent",
createPools: 'createPool', getNodesSingleRrd: "getNodeRRD",
getPoolsSingle: 'getPool', getNodesSingleRrddata: "getNodeRRDData",
updatePoolsSingle: 'updatePool', createPools: "createPool",
deletePoolsSingle: 'deletePool', getPoolsSingle: "getPool",
getNodesSingle: 'getNode', updatePoolsSingle: "updatePool",
getClusterSdn: 'getClusterSDN', deletePoolsSingle: "deletePool",
updateClusterSdn: 'updateClusterSDN', getNodesSingle: "getNode",
getClusterSdnVnets: 'getClusterSDNVnets', getClusterSdn: "getClusterSDN",
createClusterSdnVnets: 'createClusterSDNVnet', updateClusterSdn: "updateClusterSDN",
getClusterSdnVnetsSingle: 'getClusterSDNVnet', getClusterSdnVnets: "getClusterSDNVnets",
updateClusterSdnVnetsSingle: 'updateClusterSDNVnet', createClusterSdnVnets: "createClusterSDNVnet",
deleteClusterSdnVnetsSingle: 'deleteClusterSDNVnet', getClusterSdnVnetsSingle: "getClusterSDNVnet",
getClusterSdnZones: 'getClusterSDNZones', updateClusterSdnVnetsSingle: "updateClusterSDNVnet",
createClusterSdnZones: 'createClusterSDNZone', deleteClusterSdnVnetsSingle: "deleteClusterSDNVnet",
getClusterSdnZonesSingle: 'getClusterSDNZone', getClusterSdnZones: "getClusterSDNZones",
updateClusterSdnZonesSingle: 'updateClusterSDNZone', createClusterSdnZones: "createClusterSDNZone",
deleteClusterSdnZonesSingle: 'deleteClusterSDNZone', getClusterSdnZonesSingle: "getClusterSDNZone",
getClusterSdnControllers: 'getClusterSDNControllers', updateClusterSdnZonesSingle: "updateClusterSDNZone",
createClusterSdnControllers: 'createClusterSDNController', deleteClusterSdnZonesSingle: "deleteClusterSDNZone",
getClusterSdnControllersSingle: 'getClusterSDNController', getClusterSdnControllers: "getClusterSDNControllers",
updateClusterSdnControllersSingle: 'updateClusterSDNController', createClusterSdnControllers: "createClusterSDNController",
deleteClusterSdnControllersSingle: 'deleteClusterSDNController', getClusterSdnControllersSingle: "getClusterSDNController",
createClusterFirewallGroups: 'createClusterFirewallGroup', updateClusterSdnControllersSingle: "updateClusterSDNController",
getClusterFirewallGroupsSingle: 'getClusterFirewallGroupRules', deleteClusterSdnControllersSingle: "deleteClusterSDNController",
createClusterFirewallGroupsSingle: 'addClusterFirewallGroupRule', createClusterFirewallGroups: "createClusterFirewallGroup",
deleteClusterFirewallGroupsSingle: 'deleteClusterFirewallGroup', getClusterFirewallGroupsSingle: "getClusterFirewallGroupRules",
getClusterFirewallGroupsSingleSingle: 'getClusterFirewallGroupRule', createClusterFirewallGroupsSingle: "addClusterFirewallGroupRule",
updateClusterFirewallGroupsSingleSingle: 'updateClusterFirewallGroupRule', deleteClusterFirewallGroupsSingle: "deleteClusterFirewallGroup",
deleteClusterFirewallGroupsSingleSingle: 'removeClusterFirewallGroupRule', getClusterFirewallGroupsSingleSingle: "getClusterFirewallGroupRule",
createClusterFirewallRules: 'addClusterFirewallRule', updateClusterFirewallGroupsSingleSingle: "updateClusterFirewallGroupRule",
getClusterFirewallRulesSingle: 'getClusterFirewallRule', deleteClusterFirewallGroupsSingleSingle: "removeClusterFirewallGroupRule",
updateClusterFirewallRulesSingle: 'updateClusterFirewallRule', createClusterFirewallRules: "addClusterFirewallRule",
deleteClusterFirewallRulesSingle: 'removeClusterFirewallRule', getClusterFirewallRulesSingle: "getClusterFirewallRule",
getClusterFirewallIpset: 'getClusterFirewallIPSets', updateClusterFirewallRulesSingle: "updateClusterFirewallRule",
createClusterFirewallIpset: 'createClusterFirewallIPSet', deleteClusterFirewallRulesSingle: "removeClusterFirewallRule",
getClusterFirewallIpsetSingle: 'getClusterFirewallIPSet', getClusterFirewallIpset: "getClusterFirewallIPSets",
createClusterFirewallIpsetSingle: 'addClusterFirewallIPSetIP', createClusterFirewallIpset: "createClusterFirewallIPSet",
deleteClusterFirewallIpsetSingle: 'deleteClusterFirewallIPSet', getClusterFirewallIpsetSingle: "getClusterFirewallIPSet",
getClusterFirewallIpsetSingleSingle: 'getClusterFirewallIPSetIP', createClusterFirewallIpsetSingle: "addClusterFirewallIPSetIP",
updateClusterFirewallIpsetSingleSingle: 'updateClusterFirewallIPSetIP', deleteClusterFirewallIpsetSingle: "deleteClusterFirewallIPSet",
deleteClusterFirewallIpsetSingleSingle: 'removeClusterFirewallIPSetIP', getClusterFirewallIpsetSingleSingle: "getClusterFirewallIPSetIP",
getNodesSingleTasks: 'getNodeTasks', updateClusterFirewallIpsetSingleSingle: "updateClusterFirewallIPSetIP",
getNodesSingleTasksSingle: 'getNodeTask', deleteClusterFirewallIpsetSingleSingle: "removeClusterFirewallIPSetIP",
deleteNodesSingleTasksSingle: 'stopNodeTask', getNodesSingleTasks: "getNodeTasks",
getNodesSingleTasksSingleLog: 'getNodeTaskLog', getNodesSingleTasksSingle: "getNodeTask",
getNodesSingleTasksSingleStatus: 'getNodeTaskStatus', deleteNodesSingleTasksSingle: "stopNodeTask",
updateNodesSingleQemuSingleResize: 'resizeVMDisk' getNodesSingleTasksSingleLog: "getNodeTaskLog",
} getNodesSingleTasksSingleStatus: "getNodeTaskStatus",
updateNodesSingleQemuSingleResize: "resizeVMDisk",
};

45
build/pnpm-lock.yaml generated Normal file
View file

@ -0,0 +1,45 @@
lockfileVersion: '9.0'
settings:
autoInstallPeers: true
excludeLinksFromLockfile: false
importers:
.:
dependencies:
js-yaml:
specifier: ^3.14.1
version: 3.14.2
packages:
argparse@1.0.10:
resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
esprima@4.0.1:
resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
engines: {node: '>=4'}
hasBin: true
js-yaml@3.14.2:
resolution: {integrity: sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==}
hasBin: true
sprintf-js@1.0.3:
resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
snapshots:
argparse@1.0.10:
dependencies:
sprintf-js: 1.0.3
esprima@4.0.1: {}
js-yaml@3.14.2:
dependencies:
argparse: 1.0.10
esprima: 4.0.1
sprintf-js@1.0.3: {}

115125
build/source.js
View file

File diff suppressed because it is too large Load diff

69053
reference/spec.v2.yaml
View file

File diff suppressed because it is too large Load diff