efiencrypt 1.0.0 → 1.1.0

package/{build-laCVTTyp.js → build-BfNzd1Cv.js}

@@ -167,25 +167,25 @@ const parseUUID = (uuid) => {
 const fail = (msg) => {
   throw new Error(msg);
 };
+const readBufferBinaryData = (binaryData) => binaryData.type === "buffer" ? binaryData.buffer : Buffer.from(binaryData.buffer, binaryData.type);
+const readFileBinaryData = (binaryData) => {
+  const start = binaryData.offset ?? 0;
+  return createReadStream(binaryData.file, {
+    start,
+    end: binaryData.size != null ? start + binaryData.size - 1 : Infinity
+  });
+};
+const binaryDataVar = (codeBuilder, binaryData) => codeBuilder.createBinaryVar(binaryData.type === "file" ? readFileBinaryData(binaryData) : readBufferBinaryData(binaryData));
 const hashData = async (hash, binaryData) => {
   if (binaryData.type === "missing") {
     return binaryData.size ?? 1;
   }
   if (binaryData.type === "file") {
     const count = new CountTransform();
-    const start = binaryData.offset ?? 0;
-    await pipeline(
-      createReadStream(binaryData.file, {
-        start,
-        end: binaryData.size != null ? start + binaryData.size - 1 : Infinity
-      }),
-      count,
-      hash,
-      { end: false }
-    );
+    await pipeline(readFileBinaryData(binaryData), count, hash, { end: false });
     return count.length;
   }
-  const buffer = binaryData.type === "buffer" ? binaryData.buffer : Buffer.from(binaryData.buffer, binaryData.type);
+  const buffer = readBufferBinaryData(binaryData);
   hash.update(buffer);
   return buffer.length;
 };
@@ -202,6 +202,13 @@ const codeBlockProtocolGuid = (codeBuilder, protocolName) => {
 `, "guidVars");
   });
 };
+const codeBlockGuid = (codeBuilder, guidString) => codeBuilder.insertOnce(`GUID-${guidString}`, (data) => {
+  data.varName = codeBuilder.createBinaryVar(parseUUID(guidString));
+});
+const nullStringTermination = Buffer.from([0, 0]);
+const codeBlockUTF16String = (codeBuilder, value) => codeBuilder.insertOnce(`string-${value}`, (data) => {
+  data.varName = codeBuilder.createBinaryVar(Buffer.concat([Buffer.from(value, "utf16le"), nullStringTermination]));
+});
 const codeBlockLoadedImage = (codeBuilder) => {
   codeBuilder.insertOnce("loadedImage", () => {
     codeBlockProtocolGuid(codeBuilder, "LOADED_IMAGE");
@@ -380,6 +387,19 @@ const handlers = {
     hash.update(secret);
     const secretVar = codeBuilder.createBinaryVar(secret);
     codeBuilder.write(`sha256_update(hash, ${secretVar}, ${secretVar}_len);
+`);
+  },
+  async efivar({ hash, codeBuilder, hashComponent }) {
+    await hashData(hash, hashComponent.value);
+    const { varName: varNameVar } = codeBlockUTF16String(codeBuilder, hashComponent.name);
+    const { varName: guidVar } = codeBlockGuid(codeBuilder, hashComponent.guid);
+    const valueVar = codeBuilder.newVar();
+    codeBuilder.write(`UINTN ${valueVar}_len = 0;
+uint8_t *${valueVar} = LibGetVariableAndSize((void*) ${varNameVar}, (void*) ${guidVar}, &${valueVar}_len);
+if (${valueVar}) {
+	sha256_update(hash, ${valueVar}, ${valueVar}_len);
+	FREE_POOL(${valueVar});
+}
 `);
   },
   smbios({ hash, codeBuilder, hashComponent, smbios }) {
@@ -498,6 +518,46 @@ const handlers = {
 `);
   }
 };
+const enrollSecureBoot = async ({ codeBuilder, config: { enrollSecureBoot: enrollSecureBoot2 } }) => {
+  if (enrollSecureBoot2) {
+    const efiGlobalVarGuid = codeBlockGuid(codeBuilder, "8be4df61-93ca-11d2-aa0d-00e098032b8c").varName;
+    const setupModeVariable = codeBlockUTF16String(codeBuilder, "SetupMode").varName;
+    const varsToSet = [
+      {
+        name: codeBlockUTF16String(codeBuilder, "KEK").varName,
+        guid: efiGlobalVarGuid,
+        value: binaryDataVar(codeBuilder, enrollSecureBoot2.kek)
+      },
+      {
+        name: codeBlockUTF16String(codeBuilder, "db").varName,
+        guid: codeBlockGuid(codeBuilder, "d719b2cb-3d3a-4596-a3bc-dad00e67656f").varName,
+        value: binaryDataVar(codeBuilder, enrollSecureBoot2.db)
+      },
+      {
+        name: codeBlockUTF16String(codeBuilder, "PK").varName,
+        guid: efiGlobalVarGuid,
+        value: binaryDataVar(codeBuilder, enrollSecureBoot2.pk)
+      }
+    ];
+    codeBuilder.write(`
+UINT8 byteVarContent = 0;
+UINTN byteVarSize = sizeof(byteVarContent);
+status = uefi_call_wrapper(RT->GetVariable, 5, ${setupModeVariable}, &${efiGlobalVarGuid}, NULL, &byteVarSize, &byteVarContent);
+if (status == EFI_SUCCESS && byteVarSize == 1 && byteVarContent) {
+`);
+    for (const { name, guid, value } of varsToSet) {
+      codeBuilder.write(`
+	status = uefi_call_wrapper(RT->SetVariable, 5, ${name}, &${guid}, EFI_VARIABLE_NON_VOLATILE
+		| EFI_VARIABLE_RUNTIME_ACCESS
+		| EFI_VARIABLE_BOOTSERVICE_ACCESS
+		| EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS, ${value}_len, ${value});
+	CHECK_ERROR(0);
+`);
+    }
+    codeBuilder.write(`}
+`);
+  }
+};
 const genCode = async (config) => {
   const codeBuilder = new CodeBuilder("/*\n * DO NOT EDIT! This file was generated automatically!\n */\n");
   codeBuilder.addHeader('"gen-code.h"');
@@ -508,8 +568,11 @@ EFI_STATUS status = 0;
   );
   codeBuilder.writeNewBlock("gen_compute_hash_vars");
   codeBuilder.writeNewBlock("gen_compute_hash_prep");
+  codeBuilder.writeNewBlock("enroll_secure_boot");
   codeBuilder.writeNewBlock("gen_compute_hash");
   codeBuilder.write("return status;\n}\n");
+  codeBuilder.curBlock = "enroll_secure_boot";
+  await enrollSecureBoot({ codeBuilder, config });
   codeBuilder.curBlock = "gen_compute_hash";
   const hash = createHash("sha256");
   const smbios = config.smbios ? parseSmbios(await readFile(config.smbios)) : void 0;
@@ -524,12 +587,390 @@ EFI_STATUS status = 0;
   await pipeline(codeBuilder.toReadable(), createWriteStream(join(config.buildFolder, "gen-code.c")));
 };
 const validate = validate10;
-const schema11 = { "properties": { "$schema": { "type": "string" }, "inputFile": { "description": "Path to the input efi file to embed.", "type": "string" }, "outputFile": { "description": "Path to the output efi file to write.", "type": "string" }, "skipGenCode": { "description": "Whether to skip generating code", "type": "boolean" }, "skipExtract": { "description": "Whether to skip extracting source code\n(can be useful if the extraction was already done)", "type": "boolean" }, "skipMake": { "description": "Whether to skip calling make\n(can be useful to change the code before calling make)", "type": "boolean" }, "buildFolder": { "description": "Folder where to build the code.\nDefaults to a temporary folder that is removed when the build is finished.", "type": "string" }, "hashComponents": { "description": "Data to include in the hash for encryption.", "type": "array", "items": { "$ref": "#/definitions/HashComponent" } }, "smbios": { "description": "Path to the input smbios dump file.\nCan be produced by: dmidecode --dump-bin <filePath>", "type": "string" } } };
+const schema11 = { "properties": { "$schema": { "type": "string" }, "inputFile": { "description": "Path to the input efi file to embed.", "type": "string" }, "outputFile": { "description": "Path to the output efi file to write.", "type": "string" }, "skipGenCode": { "description": "Whether to skip generating code", "type": "boolean" }, "skipExtract": { "description": "Whether to skip extracting source code\n(can be useful if the extraction was already done)", "type": "boolean" }, "skipMake": { "description": "Whether to skip calling make\n(can be useful to change the code before calling make)", "type": "boolean" }, "buildFolder": { "description": "Folder where to build the code.\nDefaults to a temporary folder that is removed when the build is finished.", "type": "string" }, "hashComponents": { "description": "Data to include in the hash for encryption.", "type": "array", "items": { "$ref": "#/definitions/HashComponent" } }, "smbios": { "description": "Path to the input smbios dump file.\nCan be produced by: dmidecode --dump-bin <filePath>", "type": "string" }, "enrollSecureBoot": { "description": "Secure boot keys to enroll automatically if the system is in setup mode.", "$ref": "#/definitions/SecureBootEnrollConfig" } } };
 const func2 = Object.prototype.hasOwnProperty;
-const schema32 = { "properties": { "type": { "enum": ["boot-file", "boot-hd-device", "boot-partition-device"] } } };
-const schema15 = { "anyOf": [{ "type": "object", "properties": { "table": { "$ref": "#/definitions/SmbiosTableRef" }, "offset": { "type": "number" }, "type": { "enum": ["byte", "dword", "qword", "string", "uuid", "word"], "type": "string" } }, "additionalProperties": false, "required": ["offset", "table", "type"] }, { "enum": ["baseboard-asset-tag", "baseboard-manufacturer", "baseboard-product-name", "baseboard-serial-number", "baseboard-version", "bios-release-date", "bios-revision", "bios-vendor", "bios-version", "chassis-asset-tag", "chassis-manufacturer", "chassis-serial-number", "chassis-version", "processor-manufacturer", "processor-version", "system-family", "system-manufacturer", "system-product-name", "system-serial-number", "system-sku-number", "system-uuid", "system-version"], "type": "string" }] };
-const schema16 = { "anyOf": [{ "type": "object", "properties": { "handle": { "type": "number" } }, "additionalProperties": false, "required": ["handle"] }, { "type": "object", "properties": { "type": { "type": "number" }, "index": { "type": "number" } }, "additionalProperties": false, "required": ["type"] }, { "enum": ["32-bit Memory Error", "64-bit Memory Error", "Additional Information", "Baseboard", "Boot Integrity Services", "Built-in Pointing Device", "Cache", "Chassis", "Cooling Device", "Electrical Current Probe", "Firmware Inventory", "Firmware Language", "Group Associations", "Hardware Security", "IPMI Device", "Management Controller Host Interface", "Management Device", "Management Device Component", "Management Device Threshold Data", "Memory Array Mapped Address", "Memory Channel", "Memory Controller", "Memory Device", "Memory Device Mapped Address", "Memory Module", "OEM Strings", "Onboard Devices", "Onboard Devices Extended Information", "Out-of-band Remote Access", "Physical Memory Array", "Platform Firmware", "Port Connector", "Portable Battery", "Power Supply", "Processor", "Processor Additional Information", "String Property", "System", "System Boot", "System Configuration Options", "System Event Log", "System Power Controls", "System Reset", "System Slots", "TPM Device", "Temperature Probe", "Voltage Probe"], "type": "string" }, { "type": "number" }] };
+const schema36 = { "properties": { "type": { "enum": ["boot-file", "boot-hd-device", "boot-partition-device"] } } };
+const schema18 = { "enum": ["ascii", "base64", "base64url", "binary", "hex", "latin1", "ucs-2", "ucs2", "utf-16le", "utf-8", "utf16le", "utf8"] };
+function validate14(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.buffer === void 0 && (missing0 = "buffer") || data.type === void 0 && (missing0 = "type")) {
+        validate14.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        for (const key0 in data) {
+          if (!(key0 === "type" || key0 === "buffer")) {
+            validate14.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+          }
+        }
+        {
+          if (data.type !== void 0) {
+            let data0 = data.type;
+            const _errs2 = errors;
+            if (typeof data0 !== "string") {
+              validate14.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/definitions/global.BufferEncoding/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              return false;
+            }
+            if (!(data0 === "ascii" || data0 === "base64" || data0 === "base64url" || data0 === "binary" || data0 === "hex" || data0 === "latin1" || data0 === "ucs-2" || data0 === "ucs2" || data0 === "utf-16le" || data0 === "utf-8" || data0 === "utf16le" || data0 === "utf8")) {
+              validate14.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/definitions/global.BufferEncoding/enum", keyword: "enum", params: { allowedValues: schema18.enum }, message: "must be equal to one of the allowed values" }];
+              return false;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.buffer !== void 0) {
+              const _errs5 = errors;
+              if (typeof data.buffer !== "string") {
+                validate14.errors = [{ instancePath: instancePath + "/buffer", schemaPath: "#/properties/buffer/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                return false;
+              }
+              var valid0 = _errs5 === errors;
+            } else {
+              var valid0 = true;
+            }
+          }
+        }
+      }
+    } else {
+      validate14.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate14.errors = vErrors;
+  return errors === 0;
+}
 function validate13(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const _errs0 = errors;
+  let valid0 = false;
+  const _errs1 = errors;
+  const _errs2 = errors;
+  if (errors === _errs2) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.file === void 0 && (missing0 = "file") || data.type === void 0 && (missing0 = "type")) {
+        const err0 = { instancePath, schemaPath: "#/definitions/BinaryDataFromFile/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" };
+        if (vErrors === null) {
+          vErrors = [err0];
+        } else {
+          vErrors.push(err0);
+        }
+        errors++;
+      } else {
+        const _errs4 = errors;
+        for (const key0 in data) {
+          if (!(key0 === "type" || key0 === "file" || key0 === "offset" || key0 === "size")) {
+            const err1 = { instancePath, schemaPath: "#/definitions/BinaryDataFromFile/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+            if (vErrors === null) {
+              vErrors = [err1];
+            } else {
+              vErrors.push(err1);
+            }
+            errors++;
+            break;
+          }
+        }
+        if (_errs4 === errors) {
+          if (data.type !== void 0) {
+            let data0 = data.type;
+            const _errs5 = errors;
+            if (typeof data0 !== "string") {
+              const err2 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+              if (vErrors === null) {
+                vErrors = [err2];
+              } else {
+                vErrors.push(err2);
+              }
+              errors++;
+            }
+            if ("file" !== data0) {
+              const err3 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/const", keyword: "const", params: { allowedValue: "file" }, message: "must be equal to constant" };
+              if (vErrors === null) {
+                vErrors = [err3];
+              } else {
+                vErrors.push(err3);
+              }
+              errors++;
+            }
+            var valid2 = _errs5 === errors;
+          } else {
+            var valid2 = true;
+          }
+          if (valid2) {
+            if (data.file !== void 0) {
+              const _errs7 = errors;
+              if (typeof data.file !== "string") {
+                const err4 = { instancePath: instancePath + "/file", schemaPath: "#/definitions/BinaryDataFromFile/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                  vErrors = [err4];
+                } else {
+                  vErrors.push(err4);
+                }
+                errors++;
+              }
+              var valid2 = _errs7 === errors;
+            } else {
+              var valid2 = true;
+            }
+            if (valid2) {
+              if (data.offset !== void 0) {
+                let data2 = data.offset;
+                const _errs9 = errors;
+                if (!(typeof data2 == "number" && isFinite(data2))) {
+                  const err5 = { instancePath: instancePath + "/offset", schemaPath: "#/definitions/BinaryDataFromFile/properties/offset/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                  if (vErrors === null) {
+                    vErrors = [err5];
+                  } else {
+                    vErrors.push(err5);
+                  }
+                  errors++;
+                }
+                var valid2 = _errs9 === errors;
+              } else {
+                var valid2 = true;
+              }
+              if (valid2) {
+                if (data.size !== void 0) {
+                  let data3 = data.size;
+                  const _errs11 = errors;
+                  if (!(typeof data3 == "number" && isFinite(data3))) {
+                    const err6 = { instancePath: instancePath + "/size", schemaPath: "#/definitions/BinaryDataFromFile/properties/size/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                    if (vErrors === null) {
+                      vErrors = [err6];
+                    } else {
+                      vErrors.push(err6);
+                    }
+                    errors++;
+                  }
+                  var valid2 = _errs11 === errors;
+                } else {
+                  var valid2 = true;
+                }
+              }
+            }
+          }
+        }
+      }
+    } else {
+      const err7 = { instancePath, schemaPath: "#/definitions/BinaryDataFromFile/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+      if (vErrors === null) {
+        vErrors = [err7];
+      } else {
+        vErrors.push(err7);
+      }
+      errors++;
+    }
+  }
+  var _valid0 = _errs1 === errors;
+  valid0 = valid0 || _valid0;
+  if (!valid0) {
+    const _errs13 = errors;
+    if (!validate14(data, { instancePath, parentData, parentDataProperty, rootData })) {
+      vErrors = vErrors === null ? validate14.errors : vErrors.concat(validate14.errors);
+      errors = vErrors.length;
+    }
+    var _valid0 = _errs13 === errors;
+    valid0 = valid0 || _valid0;
+    if (!valid0) {
+      const _errs14 = errors;
+      const _errs15 = errors;
+      if (errors === _errs15) {
+        if (data && typeof data == "object" && !Array.isArray(data)) {
+          let missing1;
+          if (data.buffer === void 0 && (missing1 = "buffer") || data.type === void 0 && (missing1 = "type")) {
+            const err8 = { instancePath, schemaPath: "#/definitions/BinaryDataFromBuffer/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
+            if (vErrors === null) {
+              vErrors = [err8];
+            } else {
+              vErrors.push(err8);
+            }
+            errors++;
+          } else {
+            const _errs17 = errors;
+            for (const key1 in data) {
+              if (!(key1 === "type" || key1 === "buffer")) {
+                const err9 = { instancePath, schemaPath: "#/definitions/BinaryDataFromBuffer/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                if (vErrors === null) {
+                  vErrors = [err9];
+                } else {
+                  vErrors.push(err9);
+                }
+                errors++;
+                break;
+              }
+            }
+            if (_errs17 === errors) {
+              if (data.type !== void 0) {
+                let data4 = data.type;
+                const _errs18 = errors;
+                if (typeof data4 !== "string") {
+                  const err10 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                  if (vErrors === null) {
+                    vErrors = [err10];
+                  } else {
+                    vErrors.push(err10);
+                  }
+                  errors++;
+                }
+                if ("buffer" !== data4) {
+                  const err11 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/const", keyword: "const", params: { allowedValue: "buffer" }, message: "must be equal to constant" };
+                  if (vErrors === null) {
+                    vErrors = [err11];
+                  } else {
+                    vErrors.push(err11);
+                  }
+                  errors++;
+                }
+                var valid4 = _errs18 === errors;
+              } else {
+                var valid4 = true;
+              }
+              if (valid4) {
+                if (data.buffer !== void 0) {
+                  let data5 = data.buffer;
+                  const _errs20 = errors;
+                  if (!(data5 && typeof data5 == "object" && !Array.isArray(data5))) {
+                    const err12 = { instancePath: instancePath + "/buffer", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/buffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                    if (vErrors === null) {
+                      vErrors = [err12];
+                    } else {
+                      vErrors.push(err12);
+                    }
+                    errors++;
+                  }
+                  var valid4 = _errs20 === errors;
+                } else {
+                  var valid4 = true;
+                }
+              }
+            }
+          }
+        } else {
+          const err13 = { instancePath, schemaPath: "#/definitions/BinaryDataFromBuffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+          if (vErrors === null) {
+            vErrors = [err13];
+          } else {
+            vErrors.push(err13);
+          }
+          errors++;
+        }
+      }
+      var _valid0 = _errs14 === errors;
+      valid0 = valid0 || _valid0;
+    }
+  }
+  if (!valid0) {
+    const err14 = { instancePath, schemaPath: "#/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+    if (vErrors === null) {
+      vErrors = [err14];
+    } else {
+      vErrors.push(err14);
+    }
+    errors++;
+    validate13.errors = vErrors;
+    return false;
+  } else {
+    errors = _errs0;
+    if (vErrors !== null) {
+      if (_errs0) {
+        vErrors.length = _errs0;
+      } else {
+        vErrors = null;
+      }
+    }
+  }
+  validate13.errors = vErrors;
+  return errors === 0;
+}
+function validate12(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.guid === void 0 && (missing0 = "guid") || data.name === void 0 && (missing0 = "name") || data.type === void 0 && (missing0 = "type") || data.value === void 0 && (missing0 = "value")) {
+        validate12.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        const _errs1 = errors;
+        for (const key0 in data) {
+          if (!(key0 === "type" || key0 === "guid" || key0 === "name" || key0 === "value")) {
+            validate12.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+          }
+        }
+        if (_errs1 === errors) {
+          if (data.type !== void 0) {
+            let data0 = data.type;
+            const _errs2 = errors;
+            if (typeof data0 !== "string") {
+              validate12.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              return false;
+            }
+            if ("efivar" !== data0) {
+              validate12.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "efivar" }, message: "must be equal to constant" }];
+              return false;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.guid !== void 0) {
+              const _errs4 = errors;
+              if (typeof data.guid !== "string") {
+                validate12.errors = [{ instancePath: instancePath + "/guid", schemaPath: "#/properties/guid/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                return false;
+              }
+              var valid0 = _errs4 === errors;
+            } else {
+              var valid0 = true;
+            }
+            if (valid0) {
+              if (data.name !== void 0) {
+                const _errs6 = errors;
+                if (typeof data.name !== "string") {
+                  validate12.errors = [{ instancePath: instancePath + "/name", schemaPath: "#/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  return false;
+                }
+                var valid0 = _errs6 === errors;
+              } else {
+                var valid0 = true;
+              }
+              if (valid0) {
+                if (data.value !== void 0) {
+                  const _errs8 = errors;
+                  if (!validate13(data.value, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
+                    vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+                    errors = vErrors.length;
+                  }
+                  var valid0 = _errs8 === errors;
+                } else {
+                  var valid0 = true;
+                }
+              }
+            }
+          }
+        }
+      }
+    } else {
+      validate12.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate12.errors = vErrors;
+  return errors === 0;
+}
+const schema21 = { "anyOf": [{ "type": "object", "properties": { "table": { "$ref": "#/definitions/SmbiosTableRef" }, "offset": { "type": "number" }, "type": { "enum": ["byte", "dword", "qword", "string", "uuid", "word"], "type": "string" } }, "additionalProperties": false, "required": ["offset", "table", "type"] }, { "enum": ["baseboard-asset-tag", "baseboard-manufacturer", "baseboard-product-name", "baseboard-serial-number", "baseboard-version", "bios-release-date", "bios-revision", "bios-vendor", "bios-version", "chassis-asset-tag", "chassis-manufacturer", "chassis-serial-number", "chassis-version", "processor-manufacturer", "processor-version", "system-family", "system-manufacturer", "system-product-name", "system-serial-number", "system-sku-number", "system-uuid", "system-version"], "type": "string" }] };
+const schema22 = { "anyOf": [{ "type": "object", "properties": { "handle": { "type": "number" } }, "additionalProperties": false, "required": ["handle"] }, { "type": "object", "properties": { "type": { "type": "number" }, "index": { "type": "number" } }, "additionalProperties": false, "required": ["type"] }, { "enum": ["32-bit Memory Error", "64-bit Memory Error", "Additional Information", "Baseboard", "Boot Integrity Services", "Built-in Pointing Device", "Cache", "Chassis", "Cooling Device", "Electrical Current Probe", "Firmware Inventory", "Firmware Language", "Group Associations", "Hardware Security", "IPMI Device", "Management Controller Host Interface", "Management Device", "Management Device Component", "Management Device Threshold Data", "Memory Array Mapped Address", "Memory Channel", "Memory Controller", "Memory Device", "Memory Device Mapped Address", "Memory Module", "OEM Strings", "Onboard Devices", "Onboard Devices Extended Information", "Out-of-band Remote Access", "Physical Memory Array", "Platform Firmware", "Port Connector", "Portable Battery", "Power Supply", "Processor", "Processor Additional Information", "String Property", "System", "System Boot", "System Configuration Options", "System Event Log", "System Power Controls", "System Reset", "System Slots", "TPM Device", "Temperature Probe", "Voltage Probe"], "type": "string" }, { "type": "number" }] };
+function validate19(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
   let vErrors = null;
   let errors = 0;
   const _errs0 = errors;
@@ -707,7 +1148,7 @@ function validate13(data, { instancePath = "", parentData, parentDataProperty, r
                   errors++;
                 }
                 if (!(data0 === "32-bit Memory Error" || data0 === "64-bit Memory Error" || data0 === "Additional Information" || data0 === "Baseboard" || data0 === "Boot Integrity Services" || data0 === "Built-in Pointing Device" || data0 === "Cache" || data0 === "Chassis" || data0 === "Cooling Device" || data0 === "Electrical Current Probe" || data0 === "Firmware Inventory" || data0 === "Firmware Language" || data0 === "Group Associations" || data0 === "Hardware Security" || data0 === "IPMI Device" || data0 === "Management Controller Host Interface" || data0 === "Management Device" || data0 === "Management Device Component" || data0 === "Management Device Threshold Data" || data0 === "Memory Array Mapped Address" || data0 === "Memory Channel" || data0 === "Memory Controller" || data0 === "Memory Device" || data0 === "Memory Device Mapped Address" || data0 === "Memory Module" || data0 === "OEM Strings" || data0 === "Onboard Devices" || data0 === "Onboard Devices Extended Information" || data0 === "Out-of-band Remote Access" || data0 === "Physical Memory Array" || data0 === "Platform Firmware" || data0 === "Port Connector" || data0 === "Portable Battery" || data0 === "Power Supply" || data0 === "Processor" || data0 === "Processor Additional Information" || data0 === "String Property" || data0 === "System" || data0 === "System Boot" || data0 === "System Configuration Options" || data0 === "System Event Log" || data0 === "System Power Controls" || data0 === "System Reset" || data0 === "System Slots" || data0 === "TPM Device" || data0 === "Temperature Probe" || data0 === "Voltage Probe")) {
-                  const err12 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf/2/enum", keyword: "enum", params: { allowedValues: schema16.anyOf[2].enum }, message: "must be equal to one of the allowed values" };
+                  const err12 = { instancePath: instancePath + "/table", schemaPath: "#/definitions/SmbiosTableRef/anyOf/2/enum", keyword: "enum", params: { allowedValues: schema22.anyOf[2].enum }, message: "must be equal to one of the allowed values" };
                   if (vErrors === null) {
                     vErrors = [err12];
                   } else {
@@ -786,7 +1227,7 @@ function validate13(data, { instancePath = "", parentData, parentDataProperty, r
                   errors++;
                 }
                 if (!(data5 === "byte" || data5 === "dword" || data5 === "qword" || data5 === "string" || data5 === "uuid" || data5 === "word")) {
-                  const err17 = { instancePath: instancePath + "/type", schemaPath: "#/anyOf/0/properties/type/enum", keyword: "enum", params: { allowedValues: schema15.anyOf[0].properties.type.enum }, message: "must be equal to one of the allowed values" };
+                  const err17 = { instancePath: instancePath + "/type", schemaPath: "#/anyOf/0/properties/type/enum", keyword: "enum", params: { allowedValues: schema21.anyOf[0].properties.type.enum }, message: "must be equal to one of the allowed values" };
                   if (vErrors === null) {
                     vErrors = [err17];
                   } else {
@@ -826,7 +1267,7 @@ function validate13(data, { instancePath = "", parentData, parentDataProperty, r
       errors++;
     }
     if (!(data === "baseboard-asset-tag" || data === "baseboard-manufacturer" || data === "baseboard-product-name" || data === "baseboard-serial-number" || data === "baseboard-version" || data === "bios-release-date" || data === "bios-revision" || data === "bios-vendor" || data === "bios-version" || data === "chassis-asset-tag" || data === "chassis-manufacturer" || data === "chassis-serial-number" || data === "chassis-version" || data === "processor-manufacturer" || data === "processor-version" || data === "system-family" || data === "system-manufacturer" || data === "system-product-name" || data === "system-serial-number" || data === "system-sku-number" || data === "system-uuid" || data === "system-version")) {
-      const err20 = { instancePath, schemaPath: "#/anyOf/1/enum", keyword: "enum", params: { allowedValues: schema15.anyOf[1].enum }, message: "must be equal to one of the allowed values" };
+      const err20 = { instancePath, schemaPath: "#/anyOf/1/enum", keyword: "enum", params: { allowedValues: schema21.anyOf[1].enum }, message: "must be equal to one of the allowed values" };
       if (vErrors === null) {
         vErrors = [err20];
       } else {
@@ -845,7 +1286,7 @@ function validate13(data, { instancePath = "", parentData, parentDataProperty, r
       vErrors.push(err21);
     }
     errors++;
-    validate13.errors = vErrors;
+    validate19.errors = vErrors;
     return false;
   } else {
     errors = _errs0;
@@ -857,23 +1298,23 @@ function validate13(data, { instancePath = "", parentData, parentDataProperty, r
       }
     }
   }
-  validate13.errors = vErrors;
+  validate19.errors = vErrors;
   return errors === 0;
 }
-function validate12(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate18(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
   let vErrors = null;
   let errors = 0;
   if (errors === 0) {
     if (data && typeof data == "object" && !Array.isArray(data)) {
       let missing0;
       if (data.ref === void 0 && (missing0 = "ref") || data.type === void 0 && (missing0 = "type")) {
-        validate12.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        validate18.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
         return false;
       } else {
         const _errs1 = errors;
         for (const key0 in data) {
           if (!(key0 === "type" || key0 === "ref" || key0 === "value")) {
-            validate12.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            validate18.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
             return false;
           }
         }
@@ -882,11 +1323,11 @@ function validate12(data, { instancePath = "", parentData, parentDataProperty, r
             let data0 = data.type;
             const _errs2 = errors;
             if (typeof data0 !== "string") {
-              validate12.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              validate18.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
               return false;
             }
             if ("smbios" !== data0) {
-              validate12.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "smbios" }, message: "must be equal to constant" }];
+              validate18.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "smbios" }, message: "must be equal to constant" }];
               return false;
             }
             var valid0 = _errs2 === errors;
@@ -896,8 +1337,8 @@ function validate12(data, { instancePath = "", parentData, parentDataProperty, r
           if (valid0) {
             if (data.ref !== void 0) {
               const _errs4 = errors;
-              if (!validate13(data.ref, { instancePath: instancePath + "/ref", parentData: data, parentDataProperty: "ref", rootData })) {
-                vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+              if (!validate19(data.ref, { instancePath: instancePath + "/ref", parentData: data, parentDataProperty: "ref", rootData })) {
+                vErrors = vErrors === null ? validate19.errors : vErrors.concat(validate19.errors);
                 errors = vErrors.length;
               }
               var valid0 = _errs4 === errors;
@@ -908,7 +1349,7 @@ function validate12(data, { instancePath = "", parentData, parentDataProperty, r
               if (data.value !== void 0) {
                 const _errs5 = errors;
                 if (typeof data.value !== "string") {
-                  validate12.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  validate18.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                   return false;
                 }
                 var valid0 = _errs5 === errors;
@@ -920,84 +1361,29 @@ function validate12(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate12.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
-      return false;
-    }
-  }
-  validate12.errors = vErrors;
-  return errors === 0;
-}
-const schema17 = { "properties": { "offsetRef": { "enum": ["end", "start"] } } };
-const schema18 = { "type": ["string", "number"] };
-const schema21 = { "enum": ["ascii", "base64", "base64url", "binary", "hex", "latin1", "ucs-2", "ucs2", "utf-16le", "utf-8", "utf16le", "utf8"] };
-function validate17(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
-  let vErrors = null;
-  let errors = 0;
-  {
-    if (data && typeof data == "object" && !Array.isArray(data)) {
-      let missing0;
-      if (data.buffer === void 0 && (missing0 = "buffer") || data.type === void 0 && (missing0 = "type")) {
-        validate17.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
-        return false;
-      } else {
-        for (const key0 in data) {
-          if (!(key0 === "type" || key0 === "buffer")) {
-            validate17.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
-            return false;
-          }
-        }
-        {
-          if (data.type !== void 0) {
-            let data0 = data.type;
-            const _errs2 = errors;
-            if (typeof data0 !== "string") {
-              validate17.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/definitions/global.BufferEncoding/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-              return false;
-            }
-            if (!(data0 === "ascii" || data0 === "base64" || data0 === "base64url" || data0 === "binary" || data0 === "hex" || data0 === "latin1" || data0 === "ucs-2" || data0 === "ucs2" || data0 === "utf-16le" || data0 === "utf-8" || data0 === "utf16le" || data0 === "utf8")) {
-              validate17.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/definitions/global.BufferEncoding/enum", keyword: "enum", params: { allowedValues: schema21.enum }, message: "must be equal to one of the allowed values" }];
-              return false;
-            }
-            var valid0 = _errs2 === errors;
-          } else {
-            var valid0 = true;
-          }
-          if (valid0) {
-            if (data.buffer !== void 0) {
-              const _errs5 = errors;
-              if (typeof data.buffer !== "string") {
-                validate17.errors = [{ instancePath: instancePath + "/buffer", schemaPath: "#/properties/buffer/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                return false;
-              }
-              var valid0 = _errs5 === errors;
-            } else {
-              var valid0 = true;
-            }
-          }
-        }
-      }
-    } else {
-      validate17.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      validate18.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
       return false;
     }
   }
-  validate17.errors = vErrors;
+  validate18.errors = vErrors;
   return errors === 0;
 }
-function validate16(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+const schema23 = { "properties": { "offsetRef": { "enum": ["end", "start"] } } };
+const schema24 = { "type": ["string", "number"] };
+function validate22(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
   let vErrors = null;
   let errors = 0;
   if (errors === 0) {
     if (data && typeof data == "object" && !Array.isArray(data)) {
       let missing0;
       if (data.offset === void 0 && (missing0 = "offset") || data.offsetRef === void 0 && (missing0 = "offsetRef") || data.type === void 0 && (missing0 = "type") || data.value === void 0 && (missing0 = "value")) {
-        validate16.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        validate22.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
         return false;
       } else {
         const _errs1 = errors;
         for (const key0 in data) {
           if (!(key0 === "type" || key0 === "device" || key0 === "offsetRef" || key0 === "offset" || key0 === "value")) {
-            validate16.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            validate22.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
             return false;
           }
         }
@@ -1006,11 +1392,11 @@ function validate16(data, { instancePath = "", parentData, parentDataProperty, r
             let data0 = data.type;
             const _errs2 = errors;
             if (typeof data0 !== "string") {
-              validate16.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              validate22.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
               return false;
             }
             if ("hd-data" !== data0) {
-              validate16.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "hd-data" }, message: "must be equal to constant" }];
+              validate22.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "hd-data" }, message: "must be equal to constant" }];
               return false;
             }
             var valid0 = _errs2 === errors;
@@ -1021,7 +1407,7 @@ function validate16(data, { instancePath = "", parentData, parentDataProperty, r
             if (data.device !== void 0) {
               const _errs4 = errors;
               if (typeof data.device !== "string") {
-                validate16.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                validate22.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                 return false;
               }
               var valid0 = _errs4 === errors;
@@ -1033,11 +1419,11 @@ function validate16(data, { instancePath = "", parentData, parentDataProperty, r
                 let data2 = data.offsetRef;
                 const _errs6 = errors;
                 if (typeof data2 !== "string") {
-                  validate16.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  validate22.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                   return false;
                 }
                 if (!(data2 === "end" || data2 === "start")) {
-                  validate16.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/enum", keyword: "enum", params: { allowedValues: schema17.properties.offsetRef.enum }, message: "must be equal to one of the allowed values" }];
+                  validate22.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/enum", keyword: "enum", params: { allowedValues: schema23.properties.offsetRef.enum }, message: "must be equal to one of the allowed values" }];
                   return false;
                 }
                 var valid0 = _errs6 === errors;
@@ -1049,7 +1435,7 @@ function validate16(data, { instancePath = "", parentData, parentDataProperty, r
                   let data3 = data.offset;
                   const _errs8 = errors;
                   if (typeof data3 !== "string" && !(typeof data3 == "number" && isFinite(data3))) {
-                    validate16.errors = [{ instancePath: instancePath + "/offset", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema18.type }, message: "must be string,number" }];
+                    validate22.errors = [{ instancePath: instancePath + "/offset", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema24.type }, message: "must be string,number" }];
                     return false;
                   }
                   var valid0 = _errs8 === errors;
@@ -1184,8 +1570,8 @@ function validate16(data, { instancePath = "", parentData, parentDataProperty, r
                     valid2 = valid2 || _valid0;
                     if (!valid2) {
                       const _errs25 = errors;
-                      if (!validate17(data4, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
-                        vErrors = vErrors === null ? validate17.errors : vErrors.concat(validate17.errors);
+                      if (!validate14(data4, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
+                        vErrors = vErrors === null ? validate14.errors : vErrors.concat(validate14.errors);
                         errors = vErrors.length;
                       }
                       var _valid0 = _errs25 === errors;
@@ -1373,7 +1759,7 @@ function validate16(data, { instancePath = "", parentData, parentDataProperty, r
                         vErrors.push(err20);
                       }
                       errors++;
-                      validate16.errors = vErrors;
+                      validate22.errors = vErrors;
                       return false;
                     } else {
                       errors = _errs12;
@@ -1396,26 +1782,26 @@ function validate16(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate16.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      validate22.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
       return false;
     }
   }
-  validate16.errors = vErrors;
+  validate22.errors = vErrors;
   return errors === 0;
 }
-function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate25(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
   let vErrors = null;
   let errors = 0;
   {
     if (data && typeof data == "object" && !Array.isArray(data)) {
       let missing0;
       if (data.type === void 0 && (missing0 = "type") || data.value === void 0 && (missing0 = "value")) {
-        validate20.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        validate25.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
         return false;
       } else {
         for (const key0 in data) {
           if (!(key0 === "type" || key0 === "device" || key0 === "value")) {
-            validate20.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            validate25.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
             return false;
           }
         }
@@ -1424,11 +1810,11 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
             let data0 = data.type;
             const _errs2 = errors;
             if (typeof data0 !== "string") {
-              validate20.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              validate25.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
               return false;
             }
             if ("hd-size" !== data0) {
-              validate20.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "hd-size" }, message: "must be equal to constant" }];
+              validate25.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "hd-size" }, message: "must be equal to constant" }];
               return false;
             }
             var valid0 = _errs2 === errors;
@@ -1439,7 +1825,7 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
             if (data.device !== void 0) {
               const _errs4 = errors;
               if (typeof data.device !== "string") {
-                validate20.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                validate25.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                 return false;
               }
               var valid0 = _errs4 === errors;
@@ -1451,7 +1837,7 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
                 let data2 = data.value;
                 const _errs6 = errors;
                 if (typeof data2 !== "string" && !(typeof data2 == "number" && isFinite(data2))) {
-                  validate20.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema18.type }, message: "must be string,number" }];
+                  validate25.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema24.type }, message: "must be string,number" }];
                   return false;
                 }
                 var valid0 = _errs6 === errors;
@@ -1463,28 +1849,28 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate20.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      validate25.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
       return false;
     }
   }
-  validate20.errors = vErrors;
+  validate25.errors = vErrors;
   return errors === 0;
 }
-const schema26 = { "properties": { "offsetRef": { "enum": ["end", "full", "start"] }, "offset": { "type": ["string", "number"] } } };
-function validate22(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+const schema30 = { "properties": { "offsetRef": { "enum": ["end", "full", "start"] }, "offset": { "type": ["string", "number"] } } };
+function validate27(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
   let vErrors = null;
   let errors = 0;
   if (errors === 0) {
     if (data && typeof data == "object" && !Array.isArray(data)) {
       let missing0;
       if (data.file === void 0 && (missing0 = "file") || data.type === void 0 && (missing0 = "type") || data.value === void 0 && (missing0 = "value")) {
-        validate22.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        validate27.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
         return false;
       } else {
         const _errs1 = errors;
         for (const key0 in data) {
           if (!(key0 === "type" || key0 === "device" || key0 === "file" || key0 === "offsetRef" || key0 === "offset" || key0 === "value")) {
-            validate22.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            validate27.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
             return false;
           }
         }
@@ -1493,11 +1879,11 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
             let data0 = data.type;
             const _errs2 = errors;
             if (typeof data0 !== "string") {
-              validate22.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              validate27.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
               return false;
             }
             if ("file-data" !== data0) {
-              validate22.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "file-data" }, message: "must be equal to constant" }];
+              validate27.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "file-data" }, message: "must be equal to constant" }];
               return false;
             }
             var valid0 = _errs2 === errors;
@@ -1508,7 +1894,7 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
             if (data.device !== void 0) {
               const _errs4 = errors;
               if (typeof data.device !== "string") {
-                validate22.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                validate27.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                 return false;
               }
               var valid0 = _errs4 === errors;
@@ -1519,7 +1905,7 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
               if (data.file !== void 0) {
                 const _errs6 = errors;
                 if (typeof data.file !== "string") {
-                  validate22.errors = [{ instancePath: instancePath + "/file", schemaPath: "#/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  validate27.errors = [{ instancePath: instancePath + "/file", schemaPath: "#/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                   return false;
                 }
                 var valid0 = _errs6 === errors;
@@ -1531,11 +1917,11 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
                   let data3 = data.offsetRef;
                   const _errs8 = errors;
                   if (typeof data3 !== "string") {
-                    validate22.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                    validate27.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                     return false;
                   }
                   if (!(data3 === "end" || data3 === "full" || data3 === "start")) {
-                    validate22.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/enum", keyword: "enum", params: { allowedValues: schema26.properties.offsetRef.enum }, message: "must be equal to one of the allowed values" }];
+                    validate27.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/enum", keyword: "enum", params: { allowedValues: schema30.properties.offsetRef.enum }, message: "must be equal to one of the allowed values" }];
                     return false;
                   }
                   var valid0 = _errs8 === errors;
@@ -1547,7 +1933,7 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
                     let data4 = data.offset;
                     const _errs10 = errors;
                     if (typeof data4 !== "string" && !(typeof data4 == "number" && isFinite(data4))) {
-                      validate22.errors = [{ instancePath: instancePath + "/offset", schemaPath: "#/properties/offset/type", keyword: "type", params: { type: schema26.properties.offset.type }, message: "must be string,number" }];
+                      validate27.errors = [{ instancePath: instancePath + "/offset", schemaPath: "#/properties/offset/type", keyword: "type", params: { type: schema30.properties.offset.type }, message: "must be string,number" }];
                       return false;
                     }
                     var valid0 = _errs10 === errors;
@@ -1682,8 +2068,8 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
                       valid1 = valid1 || _valid0;
                       if (!valid1) {
                         const _errs26 = errors;
-                        if (!validate17(data5, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
-                          vErrors = vErrors === null ? validate17.errors : vErrors.concat(validate17.errors);
+                        if (!validate14(data5, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
+                          vErrors = vErrors === null ? validate14.errors : vErrors.concat(validate14.errors);
                           errors = vErrors.length;
                         }
                         var _valid0 = _errs26 === errors;
@@ -1871,7 +2257,7 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
                           vErrors.push(err20);
                         }
                         errors++;
-                        validate22.errors = vErrors;
+                        validate27.errors = vErrors;
                         return false;
                       } else {
                         errors = _errs13;
@@ -1895,26 +2281,26 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate22.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      validate27.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
       return false;
     }
   }
-  validate22.errors = vErrors;
+  validate27.errors = vErrors;
   return errors === 0;
 }
-function validate25(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate30(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
   let vErrors = null;
   let errors = 0;
   {
     if (data && typeof data == "object" && !Array.isArray(data)) {
       let missing0;
       if (data.file === void 0 && (missing0 = "file") || data.type === void 0 && (missing0 = "type") || data.value === void 0 && (missing0 = "value")) {
-        validate25.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        validate30.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
         return false;
       } else {
         for (const key0 in data) {
           if (!(key0 === "type" || key0 === "device" || key0 === "file" || key0 === "value")) {
-            validate25.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            validate30.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
             return false;
           }
         }
@@ -1923,11 +2309,11 @@ function validate25(data, { instancePath = "", parentData, parentDataProperty, r
             let data0 = data.type;
             const _errs2 = errors;
             if (typeof data0 !== "string") {
-              validate25.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              validate30.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
               return false;
             }
             if ("file-size" !== data0) {
-              validate25.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "file-size" }, message: "must be equal to constant" }];
+              validate30.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "file-size" }, message: "must be equal to constant" }];
               return false;
             }
             var valid0 = _errs2 === errors;
@@ -1938,7 +2324,7 @@ function validate25(data, { instancePath = "", parentData, parentDataProperty, r
             if (data.device !== void 0) {
               const _errs4 = errors;
               if (typeof data.device !== "string") {
-                validate25.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                validate30.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                 return false;
               }
               var valid0 = _errs4 === errors;
@@ -1949,7 +2335,7 @@ function validate25(data, { instancePath = "", parentData, parentDataProperty, r
               if (data.file !== void 0) {
                 const _errs6 = errors;
                 if (typeof data.file !== "string") {
-                  validate25.errors = [{ instancePath: instancePath + "/file", schemaPath: "#/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  validate30.errors = [{ instancePath: instancePath + "/file", schemaPath: "#/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                   return false;
                 }
                 var valid0 = _errs6 === errors;
@@ -1961,7 +2347,7 @@ function validate25(data, { instancePath = "", parentData, parentDataProperty, r
                   let data3 = data.value;
                   const _errs8 = errors;
                   if (typeof data3 !== "string" && !(typeof data3 == "number" && isFinite(data3))) {
-                    validate25.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema18.type }, message: "must be string,number" }];
+                    validate30.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema24.type }, message: "must be string,number" }];
                     return false;
                   }
                   var valid0 = _errs8 === errors;
@@ -1974,11 +2360,11 @@ function validate25(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate25.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      validate30.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
       return false;
     }
   }
-  validate25.errors = vErrors;
+  validate30.errors = vErrors;
   return errors === 0;
 }
 function validate11(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
@@ -2081,121 +2467,130 @@ function validate11(data, { instancePath = "", parentData, parentDataProperty, r
     valid0 = valid0 || _valid0;
     if (!valid0) {
       const _errs10 = errors;
-      if (!validate16(data, { instancePath, parentData, parentDataProperty, rootData })) {
-        vErrors = vErrors === null ? validate16.errors : vErrors.concat(validate16.errors);
+      if (!validate18(data, { instancePath, parentData, parentDataProperty, rootData })) {
+        vErrors = vErrors === null ? validate18.errors : vErrors.concat(validate18.errors);
         errors = vErrors.length;
       }
       var _valid0 = _errs10 === errors;
       valid0 = valid0 || _valid0;
       if (!valid0) {
         const _errs11 = errors;
-        if (!validate20(data, { instancePath, parentData, parentDataProperty, rootData })) {
-          vErrors = vErrors === null ? validate20.errors : vErrors.concat(validate20.errors);
+        if (!validate22(data, { instancePath, parentData, parentDataProperty, rootData })) {
+          vErrors = vErrors === null ? validate22.errors : vErrors.concat(validate22.errors);
           errors = vErrors.length;
         }
         var _valid0 = _errs11 === errors;
         valid0 = valid0 || _valid0;
         if (!valid0) {
           const _errs12 = errors;
-          if (!validate22(data, { instancePath, parentData, parentDataProperty, rootData })) {
-            vErrors = vErrors === null ? validate22.errors : vErrors.concat(validate22.errors);
+          if (!validate25(data, { instancePath, parentData, parentDataProperty, rootData })) {
+            vErrors = vErrors === null ? validate25.errors : vErrors.concat(validate25.errors);
             errors = vErrors.length;
           }
           var _valid0 = _errs12 === errors;
           valid0 = valid0 || _valid0;
           if (!valid0) {
             const _errs13 = errors;
-            if (!validate25(data, { instancePath, parentData, parentDataProperty, rootData })) {
-              vErrors = vErrors === null ? validate25.errors : vErrors.concat(validate25.errors);
+            if (!validate27(data, { instancePath, parentData, parentDataProperty, rootData })) {
+              vErrors = vErrors === null ? validate27.errors : vErrors.concat(validate27.errors);
               errors = vErrors.length;
             }
             var _valid0 = _errs13 === errors;
             valid0 = valid0 || _valid0;
             if (!valid0) {
               const _errs14 = errors;
-              const _errs15 = errors;
-              if (errors === _errs15) {
-                if (data && typeof data == "object" && !Array.isArray(data)) {
-                  let missing1;
-                  if (data.type === void 0 && (missing1 = "type") || data.value === void 0 && (missing1 = "value")) {
-                    const err6 = { instancePath, schemaPath: "#/definitions/HashComponentMiscStringData/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
-                    if (vErrors === null) {
-                      vErrors = [err6];
-                    } else {
-                      vErrors.push(err6);
-                    }
-                    errors++;
-                  } else {
-                    const _errs17 = errors;
-                    for (const key1 in data) {
-                      if (!(key1 === "type" || key1 === "value")) {
-                        const err7 = { instancePath, schemaPath: "#/definitions/HashComponentMiscStringData/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
-                        if (vErrors === null) {
-                          vErrors = [err7];
-                        } else {
-                          vErrors.push(err7);
-                        }
-                        errors++;
-                        break;
+              if (!validate30(data, { instancePath, parentData, parentDataProperty, rootData })) {
+                vErrors = vErrors === null ? validate30.errors : vErrors.concat(validate30.errors);
+                errors = vErrors.length;
+              }
+              var _valid0 = _errs14 === errors;
+              valid0 = valid0 || _valid0;
+              if (!valid0) {
+                const _errs15 = errors;
+                const _errs16 = errors;
+                if (errors === _errs16) {
+                  if (data && typeof data == "object" && !Array.isArray(data)) {
+                    let missing1;
+                    if (data.type === void 0 && (missing1 = "type") || data.value === void 0 && (missing1 = "value")) {
+                      const err6 = { instancePath, schemaPath: "#/definitions/HashComponentMiscStringData/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
+                      if (vErrors === null) {
+                        vErrors = [err6];
+                      } else {
+                        vErrors.push(err6);
                       }
-                    }
-                    if (_errs17 === errors) {
-                      if (data.type !== void 0) {
-                        let data2 = data.type;
-                        const _errs18 = errors;
-                        if (typeof data2 !== "string") {
-                          const err8 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/HashComponentMiscStringData/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
-                          if (vErrors === null) {
-                            vErrors = [err8];
-                          } else {
-                            vErrors.push(err8);
-                          }
-                          errors++;
-                        }
-                        if (!(data2 === "boot-file" || data2 === "boot-hd-device" || data2 === "boot-partition-device")) {
-                          const err9 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/HashComponentMiscStringData/properties/type/enum", keyword: "enum", params: { allowedValues: schema32.properties.type.enum }, message: "must be equal to one of the allowed values" };
+                      errors++;
+                    } else {
+                      const _errs18 = errors;
+                      for (const key1 in data) {
+                        if (!(key1 === "type" || key1 === "value")) {
+                          const err7 = { instancePath, schemaPath: "#/definitions/HashComponentMiscStringData/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
                           if (vErrors === null) {
-                            vErrors = [err9];
+                            vErrors = [err7];
                           } else {
-                            vErrors.push(err9);
+                            vErrors.push(err7);
                           }
                           errors++;
+                          break;
                         }
-                        var valid4 = _errs18 === errors;
-                      } else {
-                        var valid4 = true;
                       }
-                      if (valid4) {
-                        if (data.value !== void 0) {
-                          const _errs20 = errors;
-                          if (typeof data.value !== "string") {
-                            const err10 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/HashComponentMiscStringData/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                      if (_errs18 === errors) {
+                        if (data.type !== void 0) {
+                          let data2 = data.type;
+                          const _errs19 = errors;
+                          if (typeof data2 !== "string") {
+                            const err8 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/HashComponentMiscStringData/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
                             if (vErrors === null) {
-                              vErrors = [err10];
+                              vErrors = [err8];
                             } else {
-                              vErrors.push(err10);
+                              vErrors.push(err8);
                             }
                             errors++;
                           }
-                          var valid4 = _errs20 === errors;
+                          if (!(data2 === "boot-file" || data2 === "boot-hd-device" || data2 === "boot-partition-device")) {
+                            const err9 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/HashComponentMiscStringData/properties/type/enum", keyword: "enum", params: { allowedValues: schema36.properties.type.enum }, message: "must be equal to one of the allowed values" };
+                            if (vErrors === null) {
+                              vErrors = [err9];
+                            } else {
+                              vErrors.push(err9);
+                            }
+                            errors++;
+                          }
+                          var valid4 = _errs19 === errors;
                         } else {
                           var valid4 = true;
                         }
+                        if (valid4) {
+                          if (data.value !== void 0) {
+                            const _errs21 = errors;
+                            if (typeof data.value !== "string") {
+                              const err10 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/HashComponentMiscStringData/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                              if (vErrors === null) {
+                                vErrors = [err10];
+                              } else {
+                                vErrors.push(err10);
+                              }
+                              errors++;
+                            }
+                            var valid4 = _errs21 === errors;
+                          } else {
+                            var valid4 = true;
+                          }
+                        }
                       }
                     }
-                  }
-                } else {
-                  const err11 = { instancePath, schemaPath: "#/definitions/HashComponentMiscStringData/type", keyword: "type", params: { type: "object" }, message: "must be object" };
-                  if (vErrors === null) {
-                    vErrors = [err11];
                   } else {
-                    vErrors.push(err11);
+                    const err11 = { instancePath, schemaPath: "#/definitions/HashComponentMiscStringData/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                    if (vErrors === null) {
+                      vErrors = [err11];
+                    } else {
+                      vErrors.push(err11);
+                    }
+                    errors++;
                   }
-                  errors++;
                 }
+                var _valid0 = _errs15 === errors;
+                valid0 = valid0 || _valid0;
               }
-              var _valid0 = _errs14 === errors;
-              valid0 = valid0 || _valid0;
             }
           }
         }
@@ -2225,6 +2620,68 @@ function validate11(data, { instancePath = "", parentData, parentDataProperty, r
   validate11.errors = vErrors;
   return errors === 0;
 }
+function validate33(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      let missing0;
+      if (data.db === void 0 && (missing0 = "db") || data.kek === void 0 && (missing0 = "kek") || data.pk === void 0 && (missing0 = "pk")) {
+        validate33.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
+      } else {
+        const _errs1 = errors;
+        for (const key0 in data) {
+          if (!(key0 === "kek" || key0 === "db" || key0 === "pk")) {
+            validate33.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            return false;
+          }
+        }
+        if (_errs1 === errors) {
+          if (data.kek !== void 0) {
+            const _errs2 = errors;
+            if (!validate13(data.kek, { instancePath: instancePath + "/kek", parentData: data, parentDataProperty: "kek", rootData })) {
+              vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+              errors = vErrors.length;
+            }
+            var valid0 = _errs2 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.db !== void 0) {
+              const _errs3 = errors;
+              if (!validate13(data.db, { instancePath: instancePath + "/db", parentData: data, parentDataProperty: "db", rootData })) {
+                vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+                errors = vErrors.length;
+              }
+              var valid0 = _errs3 === errors;
+            } else {
+              var valid0 = true;
+            }
+            if (valid0) {
+              if (data.pk !== void 0) {
+                const _errs4 = errors;
+                if (!validate13(data.pk, { instancePath: instancePath + "/pk", parentData: data, parentDataProperty: "pk", rootData })) {
+                  vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+                  errors = vErrors.length;
+                }
+                var valid0 = _errs4 === errors;
+              } else {
+                var valid0 = true;
+              }
+            }
+          }
+        }
+      }
+    } else {
+      validate33.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      return false;
+    }
+  }
+  validate33.errors = vErrors;
+  return errors === 0;
+}
 function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
   let vErrors = null;
   let errors = 0;
@@ -2358,6 +2815,18 @@ function validate10(data, { instancePath = "", parentData, parentDataProperty, r
                           } else {
                             var valid0 = true;
                           }
+                          if (valid0) {
+                            if (data.enrollSecureBoot !== void 0) {
+                              const _errs21 = errors;
+                              if (!validate33(data.enrollSecureBoot, { instancePath: instancePath + "/enrollSecureBoot", parentData: data, parentDataProperty: "enrollSecureBoot", rootData })) {
+                                vErrors = vErrors === null ? validate33.errors : vErrors.concat(validate33.errors);
+                                errors = vErrors.length;
+                              }
+                              var valid0 = _errs21 === errors;
+                            } else {
+                              var valid0 = true;
+                            }
+                          }
                         }
                       }
                     }
@@ -2382,7 +2851,7 @@ const spawnProcess = (command, args, options) => new Promise((resolve, reject) =
     if (!code && !signal) {
       resolve();
     } else {
-      throw new Error("Command failed");
+      reject(new Error("Command failed"));
     }
   });
 });
@@ -2414,7 +2883,7 @@ const build = async (config) => {
       await genCode(config);
     }
     if (!config.skipExtract) {
-      const extract = (await import("./extract-BW1V8DVW.js")).extract;
+      const extract = (await import("./extract-BvhlZgSs.js")).extract;
       await extract(config.buildFolder);
     }
     if (!config.skipMake) {