efiencrypt 1.1.0 → 1.2.0

package/{build-BfNzd1Cv.js → build-82nMypIu.js}

@@ -168,21 +168,31 @@ 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 readFileBinaryDataStream = (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 readFileBinaryDataBuffer = async (binaryData) => {
+  const start = binaryData.offset ?? 0;
+  const buffer = await readFile(binaryData.file);
+  return start === 0 && binaryData.size == null ? buffer : buffer.subarray(start, binaryData.size != null ? start + binaryData.size - 1 : void 0);
+};
+const readBinaryData = async (binaryData) => {
+  if (binaryData.type === "file") {
+    return readFileBinaryDataBuffer(binaryData);
+  }
+  return readBufferBinaryData(binaryData);
+};
 const hashData = async (hash, binaryData) => {
   if (binaryData.type === "missing") {
     return binaryData.size ?? 1;
   }
   if (binaryData.type === "file") {
     const count = new CountTransform();
-    await pipeline(readFileBinaryData(binaryData), count, hash, { end: false });
+    await pipeline(readFileBinaryDataStream(binaryData), count, hash, { end: false });
     return count.length;
   }
   const buffer = readBufferBinaryData(binaryData);
@@ -381,6 +391,25 @@ const codeBlockGetFile = (codeBuilder, file, device) => codeBuilder.insertOnce(`
 }
 `);
 });
+const codeBlockEfiVariable = (codeBuilder, varName, guid) => codeBuilder.insertOnce(`efivar:${guid}-${varName}`, (data) => {
+  const valueVar = codeBuilder.newVar();
+  codeBuilder.write(`UINTN ${valueVar}_len = 1;
+uint8_t *${valueVar} = NULL;
+`, "gen_compute_hash_vars");
+  codeBuilder.write(`FREE_POOL(${valueVar});
+`, "gen_compute_hash_clean");
+  data.varName = valueVar;
+});
+const generateReadEfiVariable = (codeBuilder, varName, guid) => {
+  const { varName: varNameVar } = codeBlockUTF16String(codeBuilder, varName);
+  const { varName: guidVar } = codeBlockGuid(codeBuilder, guid);
+  const { varName: valueVar } = codeBlockEfiVariable(codeBuilder, varName, guid);
+  codeBuilder.write(`if (${valueVar}_len == 1 && ! ${valueVar}) {
+  ${valueVar} = LibGetVariableAndSize((void*) ${varNameVar}, (void*) ${guidVar}, &${valueVar}_len);
+}
+`);
+  return { valueVar, varNameVar, guidVar };
+};
 const handlers = {
   random({ hash, codeBuilder, hashComponent }) {
     const secret = randomBytes(hashComponent.length);
@@ -389,16 +418,14 @@ const handlers = {
     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}) {
+  async efivar({ hash, codeBuilder, hashComponent, secureBoot }) {
+    const value = hashComponent.value ?? secureBoot?.find(({ name, guid }) => hashComponent.name === name && hashComponent.guid === guid)?.value ?? fail(`Missing value for EFI variable ${hashComponent.guid}-${hashComponent.name}`);
+    if (value != "missing") {
+      await hashData(hash, value);
+    }
+    const { valueVar } = generateReadEfiVariable(codeBuilder, hashComponent.name, hashComponent.guid);
+    codeBuilder.write(`if (${valueVar}) {
 	sha256_update(hash, ${valueVar}, ${valueVar}_len);
-	FREE_POOL(${valueVar});
 }
 `);
   },
@@ -518,46 +545,84 @@ if (${valueVar}) {
 `);
   }
 };
-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) {
+const toArray = (value) => value == null ? [] : Array.isArray(value) ? value : [value];
+const EFI_GLOBAL_VARIABLE_GUID = "8be4df61-93ca-11d2-aa0d-00e098032b8c";
+const EFI_IMAGE_SECURITY_DATABASE_GUID = "d719b2cb-3d3a-4596-a3bc-dad00e67656f";
+const EFI_VAR_PK = { name: "PK", guid: EFI_GLOBAL_VARIABLE_GUID, type: "efivar" };
+const EFI_VAR_KEK = { name: "KEK", guid: EFI_GLOBAL_VARIABLE_GUID, type: "efivar" };
+const EFI_VAR_DB = { name: "db", guid: EFI_IMAGE_SECURITY_DATABASE_GUID, type: "efivar" };
+const EFI_VAR_DBX = { name: "dbx", guid: EFI_IMAGE_SECURITY_DATABASE_GUID, type: "efivar" };
+const parseAuthVar = (authVar) => {
+  const valueOffset = 16 + authVar.readUint32LE(16);
+  const auth = authVar.subarray(0, valueOffset);
+  const value = authVar.subarray(valueOffset);
+  return {
+    auth,
+    value
+  };
+};
+const generateSecureBootSetVariable = async (codeBuilder, { name, guid }, binaryData) => {
+  let value = null;
+  const auth = [];
+  let maxAuthLength = 0;
+  for (const data of toArray(binaryData)) {
+    const decodedData = parseAuthVar(await readBinaryData(data));
+    if (!value) {
+      value = decodedData.value;
+    } else if (!value.equals(decodedData.value)) {
+      throw new Error(`Inconsistent values for ${name}`);
+    }
+    maxAuthLength = Math.max(maxAuthLength, decodedData.auth.length);
+    auth.push(decodedData.auth);
+  }
+  if (!value) {
+    return [];
+  }
+  const expectedEfiVarValue = codeBuilder.createBinaryVar(value);
+  const { valueVar: efiVarValue, guidVar, varNameVar } = generateReadEfiVariable(codeBuilder, name, guid);
+  codeBuilder.write(`if (!${efiVarValue} || ${value.length} != ${efiVarValue}_len || RtCompareMem(${efiVarValue}, ${expectedEfiVarValue}, ${value.length}) != 0) {
+`);
+  const authValueName = codeBuilder.newVar();
+  codeBuilder.write(`UINT8 *${authValueName} = AllocatePool(${value.length + maxAuthLength});
+	if (${authValueName}) {
+  RtCopyMem(&${authValueName}[${maxAuthLength}], ${expectedEfiVarValue}, ${value.length});
 `);
-    for (const { name, guid, value } of varsToSet) {
-      codeBuilder.write(`
-	status = uefi_call_wrapper(RT->SetVariable, 5, ${name}, &${guid}, EFI_VARIABLE_NON_VOLATILE
+  let closingBraces = "";
+  for (const tryAuth of auth) {
+    const authVar = codeBuilder.createBinaryVar(tryAuth);
+    const pointer = `&${authValueName}[${maxAuthLength - tryAuth.length}]`;
+    codeBuilder.write(`
+	RtCopyMem(${pointer}, ${authVar}, ${tryAuth.length});
+	status = uefi_call_wrapper(RT->SetVariable, 5, ${varNameVar}, &${guidVar}, 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(`}
+		| EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS, ${tryAuth.length + value.length}, ${pointer});
+	if (status == EFI_SECURITY_VIOLATION) {
 `);
+    closingBraces += "}";
   }
+  codeBuilder.write(`${closingBraces}
+FREE_POOL(${authValueName});
+if (status == EFI_SUCCESS) {
+  FREE_POOL(${efiVarValue});
+  ${efiVarValue}_len = 1;
+}
+}}
+`);
+  return [
+    {
+      value: { type: "buffer", buffer: value },
+      name,
+      guid
+    }
+  ];
 };
+const enrollSecureBoot = async ({ codeBuilder, config: { enrollSecureBoot: enrollSecureBoot2 } }) => enrollSecureBoot2 ? [
+  ...await generateSecureBootSetVariable(codeBuilder, EFI_VAR_PK, enrollSecureBoot2.pk),
+  ...await generateSecureBootSetVariable(codeBuilder, EFI_VAR_KEK, enrollSecureBoot2.kek),
+  ...await generateSecureBootSetVariable(codeBuilder, EFI_VAR_DB, enrollSecureBoot2.db),
+  ...await generateSecureBootSetVariable(codeBuilder, EFI_VAR_DBX, enrollSecureBoot2.dbx)
+] : [];
 const genCode = async (config) => {
   const codeBuilder = new CodeBuilder("/*\n * DO NOT EDIT! This file was generated automatically!\n */\n");
   codeBuilder.addHeader('"gen-code.h"');
@@ -570,15 +635,16 @@ EFI_STATUS status = 0;
   codeBuilder.writeNewBlock("gen_compute_hash_prep");
   codeBuilder.writeNewBlock("enroll_secure_boot");
   codeBuilder.writeNewBlock("gen_compute_hash");
+  codeBuilder.writeNewBlock("gen_compute_hash_clean");
   codeBuilder.write("return status;\n}\n");
   codeBuilder.curBlock = "enroll_secure_boot";
-  await enrollSecureBoot({ codeBuilder, config });
+  const secureBoot = await enrollSecureBoot({ codeBuilder, config });
   codeBuilder.curBlock = "gen_compute_hash";
   const hash = createHash("sha256");
   const smbios = config.smbios ? parseSmbios(await readFile(config.smbios)) : void 0;
   for (const hashComponent of config.hashComponents) {
     const handler = handlers[hashComponent.type];
-    await handler({ hashComponent, codeBuilder, config, hash, smbios });
+    await handler({ hashComponent, codeBuilder, config, hash, smbios, secureBoot });
   }
   const iv = randomBytes(16);
   codeBuilder.createBinaryVar(iv, "iv");
@@ -587,23 +653,23 @@ 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" }, "enrollSecureBoot": { "description": "Secure boot keys to enroll automatically if the system is in setup mode.", "$ref": "#/definitions/SecureBootEnrollConfig" } } };
+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 keys to enroll are different than already installed keys.", "$ref": "#/definitions/SecureBootEnrollConfig" } } };
 const func2 = Object.prototype.hasOwnProperty;
-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 } = {}) {
+const schema35 = { "properties": { "type": { "enum": ["boot-file", "boot-hd-device", "boot-partition-device"] } } };
+const schema17 = { "enum": ["ascii", "base64", "base64url", "binary", "hex", "latin1", "ucs-2", "ucs2", "utf-16le", "utf-8", "utf16le", "utf8"] };
+function validate13(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 + "'" }];
+        validate13.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" }];
+            validate13.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
             return false;
           }
         }
@@ -612,11 +678,11 @@ function validate14(data, { instancePath = "", parentData, parentDataProperty, r
             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" }];
+              validate13.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" }];
+              validate13.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/definitions/global.BufferEncoding/enum", keyword: "enum", params: { allowedValues: schema17.enum }, message: "must be equal to one of the allowed values" }];
               return false;
             }
             var valid0 = _errs2 === errors;
@@ -627,7 +693,7 @@ function validate14(data, { instancePath = "", parentData, parentDataProperty, r
             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" }];
+                validate13.errors = [{ instancePath: instancePath + "/buffer", schemaPath: "#/properties/buffer/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                 return false;
               }
               var valid0 = _errs5 === errors;
@@ -638,318 +704,332 @@ function validate14(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate14.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      validate13.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
       return false;
     }
   }
-  validate14.errors = vErrors;
+  validate13.errors = vErrors;
   return errors === 0;
 }
-function validate13(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate12(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 (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")) {
-        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++;
+      if (data.guid === void 0 && (missing0 = "guid") || data.name === void 0 && (missing0 = "name") || data.type === void 0 && (missing0 = "type")) {
+        validate12.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        return false;
       } else {
-        const _errs4 = errors;
+        const _errs1 = 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 (!(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 (_errs4 === errors) {
+        if (_errs1 === errors) {
           if (data.type !== void 0) {
             let data0 = data.type;
-            const _errs5 = errors;
+            const _errs2 = 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++;
+              validate12.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              return false;
             }
-            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++;
+            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 valid2 = _errs5 === errors;
+            var valid0 = _errs2 === errors;
           } else {
-            var valid2 = true;
+            var valid0 = 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++;
+          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 valid2 = _errs7 === errors;
+              var valid0 = _errs4 === errors;
             } else {
-              var valid2 = true;
+              var valid0 = 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++;
+            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 valid2 = _errs9 === errors;
+                var valid0 = _errs6 === errors;
               } else {
-                var valid2 = true;
+                var valid0 = true;
               }
-              if (valid2) {
-                if (data.size !== void 0) {
-                  let data3 = data.size;
+              if (valid0) {
+                if (data.value !== void 0) {
+                  let data3 = data.value;
+                  const _errs8 = errors;
+                  const _errs9 = errors;
+                  let valid1 = false;
+                  const _errs10 = errors;
                   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];
+                  if (errors === _errs11) {
+                    if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+                      let missing1;
+                      if (data3.file === void 0 && (missing1 = "file") || data3.type === void 0 && (missing1 = "type")) {
+                        const err0 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromFile/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
+                        if (vErrors === null) {
+                          vErrors = [err0];
+                        } else {
+                          vErrors.push(err0);
+                        }
+                        errors++;
+                      } else {
+                        const _errs13 = errors;
+                        for (const key1 in data3) {
+                          if (!(key1 === "type" || key1 === "file" || key1 === "offset" || key1 === "size")) {
+                            const err1 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromFile/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                            if (vErrors === null) {
+                              vErrors = [err1];
+                            } else {
+                              vErrors.push(err1);
+                            }
+                            errors++;
+                            break;
+                          }
+                        }
+                        if (_errs13 === errors) {
+                          if (data3.type !== void 0) {
+                            let data4 = data3.type;
+                            const _errs14 = errors;
+                            if (typeof data4 !== "string") {
+                              const err2 = { instancePath: instancePath + "/value/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" !== data4) {
+                              const err3 = { instancePath: instancePath + "/value/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 valid3 = _errs14 === errors;
+                          } else {
+                            var valid3 = true;
+                          }
+                          if (valid3) {
+                            if (data3.file !== void 0) {
+                              const _errs16 = errors;
+                              if (typeof data3.file !== "string") {
+                                const err4 = { instancePath: instancePath + "/value/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 valid3 = _errs16 === errors;
+                            } else {
+                              var valid3 = true;
+                            }
+                            if (valid3) {
+                              if (data3.offset !== void 0) {
+                                let data6 = data3.offset;
+                                const _errs18 = errors;
+                                if (!(typeof data6 == "number" && isFinite(data6))) {
+                                  const err5 = { instancePath: instancePath + "/value/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 valid3 = _errs18 === errors;
+                              } else {
+                                var valid3 = true;
+                              }
+                              if (valid3) {
+                                if (data3.size !== void 0) {
+                                  let data7 = data3.size;
+                                  const _errs20 = errors;
+                                  if (!(typeof data7 == "number" && isFinite(data7))) {
+                                    const err6 = { instancePath: instancePath + "/value/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 valid3 = _errs20 === errors;
+                                } else {
+                                  var valid3 = true;
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
                     } else {
-                      vErrors.push(err6);
+                      const err7 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromFile/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                      if (vErrors === null) {
+                        vErrors = [err7];
+                      } else {
+                        vErrors.push(err7);
+                      }
+                      errors++;
                     }
-                    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);
+                  var _valid0 = _errs10 === errors;
+                  valid1 = valid1 || _valid0;
+                  if (!valid1) {
+                    const _errs22 = errors;
+                    if (!validate13(data3, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
+                      vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+                      errors = vErrors.length;
+                    }
+                    var _valid0 = _errs22 === errors;
+                    valid1 = valid1 || _valid0;
+                    if (!valid1) {
+                      const _errs23 = errors;
+                      const _errs24 = errors;
+                      if (errors === _errs24) {
+                        if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+                          let missing2;
+                          if (data3.buffer === void 0 && (missing2 = "buffer") || data3.type === void 0 && (missing2 = "type")) {
+                            const err8 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromBuffer/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" };
+                            if (vErrors === null) {
+                              vErrors = [err8];
+                            } else {
+                              vErrors.push(err8);
+                            }
+                            errors++;
+                          } else {
+                            const _errs26 = errors;
+                            for (const key2 in data3) {
+                              if (!(key2 === "type" || key2 === "buffer")) {
+                                const err9 = { instancePath: instancePath + "/value", schemaPath: "#/definitions/BinaryDataFromBuffer/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+                                if (vErrors === null) {
+                                  vErrors = [err9];
+                                } else {
+                                  vErrors.push(err9);
+                                }
+                                errors++;
+                                break;
+                              }
+                            }
+                            if (_errs26 === errors) {
+                              if (data3.type !== void 0) {
+                                let data8 = data3.type;
+                                const _errs27 = errors;
+                                if (typeof data8 !== "string") {
+                                  const err10 = { instancePath: instancePath + "/value/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" !== data8) {
+                                  const err11 = { instancePath: instancePath + "/value/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 valid5 = _errs27 === errors;
+                              } else {
+                                var valid5 = true;
+                              }
+                              if (valid5) {
+                                if (data3.buffer !== void 0) {
+                                  let data9 = data3.buffer;
+                                  const _errs29 = errors;
+                                  if (!(data9 && typeof data9 == "object" && !Array.isArray(data9))) {
+                                    const err12 = { instancePath: instancePath + "/value/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 valid5 = _errs29 === errors;
+                                } else {
+                                  var valid5 = true;
+                                }
+                              }
+                            }
+                          }
+                        } else {
+                          const err13 = { instancePath: instancePath + "/value", 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 = _errs23 === errors;
+                      valid1 = valid1 || _valid0;
+                      if (!valid1) {
+                        const _errs31 = errors;
+                        if (typeof data3 !== "string") {
+                          const err14 = { instancePath: instancePath + "/value", schemaPath: "#/properties/value/anyOf/3/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                          if (vErrors === null) {
+                            vErrors = [err14];
+                          } else {
+                            vErrors.push(err14);
+                          }
+                          errors++;
+                        }
+                        if ("missing" !== data3) {
+                          const err15 = { instancePath: instancePath + "/value", schemaPath: "#/properties/value/anyOf/3/const", keyword: "const", params: { allowedValue: "missing" }, message: "must be equal to constant" };
+                          if (vErrors === null) {
+                            vErrors = [err15];
+                          } else {
+                            vErrors.push(err15);
+                          }
+                          errors++;
+                        }
+                        var _valid0 = _errs31 === errors;
+                        valid1 = valid1 || _valid0;
+                      }
+                    }
                   }
-                  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 (!valid1) {
+                    const err16 = { instancePath: instancePath + "/value", schemaPath: "#/properties/value/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
                     if (vErrors === null) {
-                      vErrors = [err12];
+                      vErrors = [err16];
                     } else {
-                      vErrors.push(err12);
+                      vErrors.push(err16);
                     }
                     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;
+                    validate12.errors = vErrors;
+                    return false;
+                  } else {
+                    errors = _errs9;
+                    if (vErrors !== null) {
+                      if (_errs9) {
+                        vErrors.length = _errs9;
+                      } else {
+                        vErrors = null;
+                      }
+                    }
                   }
                   var valid0 = _errs8 === errors;
                 } else {
@@ -968,9 +1048,9 @@ function validate12(data, { instancePath = "", parentData, parentDataProperty, r
   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 } = {}) {
+const schema20 = { "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 schema21 = { "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 validate17(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
   let vErrors = null;
   let errors = 0;
   const _errs0 = errors;
@@ -1148,7 +1228,7 @@ function validate19(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: schema22.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: schema21.anyOf[2].enum }, message: "must be equal to one of the allowed values" };
                   if (vErrors === null) {
                     vErrors = [err12];
                   } else {
@@ -1227,7 +1307,7 @@ function validate19(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: schema21.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: schema20.anyOf[0].properties.type.enum }, message: "must be equal to one of the allowed values" };
                   if (vErrors === null) {
                     vErrors = [err17];
                   } else {
@@ -1267,7 +1347,7 @@ function validate19(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: schema21.anyOf[1].enum }, message: "must be equal to one of the allowed values" };
+      const err20 = { instancePath, schemaPath: "#/anyOf/1/enum", keyword: "enum", params: { allowedValues: schema20.anyOf[1].enum }, message: "must be equal to one of the allowed values" };
       if (vErrors === null) {
         vErrors = [err20];
       } else {
@@ -1286,7 +1366,7 @@ function validate19(data, { instancePath = "", parentData, parentDataProperty, r
       vErrors.push(err21);
     }
     errors++;
-    validate19.errors = vErrors;
+    validate17.errors = vErrors;
     return false;
   } else {
     errors = _errs0;
@@ -1298,23 +1378,23 @@ function validate19(data, { instancePath = "", parentData, parentDataProperty, r
       }
     }
   }
-  validate19.errors = vErrors;
+  validate17.errors = vErrors;
   return errors === 0;
 }
-function validate18(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate16(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")) {
-        validate18.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        validate16.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")) {
-            validate18.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            validate16.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
             return false;
           }
         }
@@ -1323,11 +1403,11 @@ function validate18(data, { instancePath = "", parentData, parentDataProperty, r
             let data0 = data.type;
             const _errs2 = errors;
             if (typeof data0 !== "string") {
-              validate18.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              validate16.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
               return false;
             }
             if ("smbios" !== data0) {
-              validate18.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "smbios" }, message: "must be equal to constant" }];
+              validate16.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;
@@ -1337,8 +1417,8 @@ function validate18(data, { instancePath = "", parentData, parentDataProperty, r
           if (valid0) {
             if (data.ref !== void 0) {
               const _errs4 = errors;
-              if (!validate19(data.ref, { instancePath: instancePath + "/ref", parentData: data, parentDataProperty: "ref", rootData })) {
-                vErrors = vErrors === null ? validate19.errors : vErrors.concat(validate19.errors);
+              if (!validate17(data.ref, { instancePath: instancePath + "/ref", parentData: data, parentDataProperty: "ref", rootData })) {
+                vErrors = vErrors === null ? validate17.errors : vErrors.concat(validate17.errors);
                 errors = vErrors.length;
               }
               var valid0 = _errs4 === errors;
@@ -1349,7 +1429,7 @@ function validate18(data, { instancePath = "", parentData, parentDataProperty, r
               if (data.value !== void 0) {
                 const _errs5 = errors;
                 if (typeof data.value !== "string") {
-                  validate18.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  validate16.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/properties/value/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                   return false;
                 }
                 var valid0 = _errs5 === errors;
@@ -1361,29 +1441,29 @@ function validate18(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate18.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      validate16.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
       return false;
     }
   }
-  validate18.errors = vErrors;
+  validate16.errors = vErrors;
   return errors === 0;
 }
-const schema23 = { "properties": { "offsetRef": { "enum": ["end", "start"] } } };
-const schema24 = { "type": ["string", "number"] };
-function validate22(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+const schema22 = { "properties": { "offsetRef": { "enum": ["end", "start"] } } };
+const schema23 = { "type": ["string", "number"] };
+function validate20(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")) {
-        validate22.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        validate20.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")) {
-            validate22.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            validate20.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
             return false;
           }
         }
@@ -1392,11 +1472,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" }];
+              validate20.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
               return false;
             }
             if ("hd-data" !== data0) {
-              validate22.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "hd-data" }, message: "must be equal to constant" }];
+              validate20.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;
@@ -1407,7 +1487,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" }];
+                validate20.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                 return false;
               }
               var valid0 = _errs4 === errors;
@@ -1419,11 +1499,11 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
                 let data2 = data.offsetRef;
                 const _errs6 = errors;
                 if (typeof data2 !== "string") {
-                  validate22.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  validate20.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                   return false;
                 }
                 if (!(data2 === "end" || data2 === "start")) {
-                  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" }];
+                  validate20.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/enum", keyword: "enum", params: { allowedValues: schema22.properties.offsetRef.enum }, message: "must be equal to one of the allowed values" }];
                   return false;
                 }
                 var valid0 = _errs6 === errors;
@@ -1435,7 +1515,7 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
                   let data3 = data.offset;
                   const _errs8 = errors;
                   if (typeof data3 !== "string" && !(typeof data3 == "number" && isFinite(data3))) {
-                    validate22.errors = [{ instancePath: instancePath + "/offset", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema24.type }, message: "must be string,number" }];
+                    validate20.errors = [{ instancePath: instancePath + "/offset", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema23.type }, message: "must be string,number" }];
                     return false;
                   }
                   var valid0 = _errs8 === errors;
@@ -1570,8 +1650,8 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
                     valid2 = valid2 || _valid0;
                     if (!valid2) {
                       const _errs25 = errors;
-                      if (!validate14(data4, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
-                        vErrors = vErrors === null ? validate14.errors : vErrors.concat(validate14.errors);
+                      if (!validate13(data4, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
+                        vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
                         errors = vErrors.length;
                       }
                       var _valid0 = _errs25 === errors;
@@ -1759,7 +1839,7 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
                         vErrors.push(err20);
                       }
                       errors++;
-                      validate22.errors = vErrors;
+                      validate20.errors = vErrors;
                       return false;
                     } else {
                       errors = _errs12;
@@ -1782,26 +1862,26 @@ function validate22(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate22.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      validate20.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
       return false;
     }
   }
-  validate22.errors = vErrors;
+  validate20.errors = vErrors;
   return errors === 0;
 }
-function validate25(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate23(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")) {
-        validate25.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        validate23.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")) {
-            validate25.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            validate23.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
             return false;
           }
         }
@@ -1810,11 +1890,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" }];
+              validate23.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
               return false;
             }
             if ("hd-size" !== data0) {
-              validate25.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "hd-size" }, message: "must be equal to constant" }];
+              validate23.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;
@@ -1825,7 +1905,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" }];
+                validate23.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                 return false;
               }
               var valid0 = _errs4 === errors;
@@ -1837,7 +1917,7 @@ function validate25(data, { instancePath = "", parentData, parentDataProperty, r
                 let data2 = data.value;
                 const _errs6 = errors;
                 if (typeof data2 !== "string" && !(typeof data2 == "number" && isFinite(data2))) {
-                  validate25.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema24.type }, message: "must be string,number" }];
+                  validate23.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema23.type }, message: "must be string,number" }];
                   return false;
                 }
                 var valid0 = _errs6 === errors;
@@ -1849,28 +1929,28 @@ function validate25(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate25.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      validate23.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
       return false;
     }
   }
-  validate25.errors = vErrors;
+  validate23.errors = vErrors;
   return errors === 0;
 }
-const schema30 = { "properties": { "offsetRef": { "enum": ["end", "full", "start"] }, "offset": { "type": ["string", "number"] } } };
-function validate27(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+const schema29 = { "properties": { "offsetRef": { "enum": ["end", "full", "start"] }, "offset": { "type": ["string", "number"] } } };
+function validate25(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")) {
-        validate27.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 {
         const _errs1 = errors;
         for (const key0 in data) {
           if (!(key0 === "type" || key0 === "device" || key0 === "file" || key0 === "offsetRef" || key0 === "offset" || key0 === "value")) {
-            validate27.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;
           }
         }
@@ -1879,11 +1959,11 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
             let data0 = data.type;
             const _errs2 = errors;
             if (typeof data0 !== "string") {
-              validate27.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 ("file-data" !== data0) {
-              validate27.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "file-data" }, message: "must be equal to constant" }];
+              validate25.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;
@@ -1894,7 +1974,7 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
             if (data.device !== void 0) {
               const _errs4 = errors;
               if (typeof data.device !== "string") {
-                validate27.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;
@@ -1905,7 +1985,7 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
               if (data.file !== void 0) {
                 const _errs6 = errors;
                 if (typeof data.file !== "string") {
-                  validate27.errors = [{ instancePath: instancePath + "/file", schemaPath: "#/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  validate25.errors = [{ instancePath: instancePath + "/file", schemaPath: "#/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                   return false;
                 }
                 var valid0 = _errs6 === errors;
@@ -1917,11 +1997,11 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                   let data3 = data.offsetRef;
                   const _errs8 = errors;
                   if (typeof data3 !== "string") {
-                    validate27.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                    validate25.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")) {
-                    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" }];
+                    validate25.errors = [{ instancePath: instancePath + "/offsetRef", schemaPath: "#/properties/offsetRef/enum", keyword: "enum", params: { allowedValues: schema29.properties.offsetRef.enum }, message: "must be equal to one of the allowed values" }];
                     return false;
                   }
                   var valid0 = _errs8 === errors;
@@ -1933,7 +2013,7 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                     let data4 = data.offset;
                     const _errs10 = errors;
                     if (typeof data4 !== "string" && !(typeof data4 == "number" && isFinite(data4))) {
-                      validate27.errors = [{ instancePath: instancePath + "/offset", schemaPath: "#/properties/offset/type", keyword: "type", params: { type: schema30.properties.offset.type }, message: "must be string,number" }];
+                      validate25.errors = [{ instancePath: instancePath + "/offset", schemaPath: "#/properties/offset/type", keyword: "type", params: { type: schema29.properties.offset.type }, message: "must be string,number" }];
                       return false;
                     }
                     var valid0 = _errs10 === errors;
@@ -2068,8 +2148,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                       valid1 = valid1 || _valid0;
                       if (!valid1) {
                         const _errs26 = errors;
-                        if (!validate14(data5, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
-                          vErrors = vErrors === null ? validate14.errors : vErrors.concat(validate14.errors);
+                        if (!validate13(data5, { instancePath: instancePath + "/value", parentData: data, parentDataProperty: "value", rootData })) {
+                          vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
                           errors = vErrors.length;
                         }
                         var _valid0 = _errs26 === errors;
@@ -2257,7 +2337,7 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
                           vErrors.push(err20);
                         }
                         errors++;
-                        validate27.errors = vErrors;
+                        validate25.errors = vErrors;
                         return false;
                       } else {
                         errors = _errs13;
@@ -2281,26 +2361,26 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate27.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;
     }
   }
-  validate27.errors = vErrors;
+  validate25.errors = vErrors;
   return errors === 0;
 }
-function validate30(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+function validate28(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")) {
-        validate30.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+        validate28.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")) {
-            validate30.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+            validate28.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
             return false;
           }
         }
@@ -2309,11 +2389,11 @@ function validate30(data, { instancePath = "", parentData, parentDataProperty, r
             let data0 = data.type;
             const _errs2 = errors;
             if (typeof data0 !== "string") {
-              validate30.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+              validate28.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
               return false;
             }
             if ("file-size" !== data0) {
-              validate30.errors = [{ instancePath: instancePath + "/type", schemaPath: "#/properties/type/const", keyword: "const", params: { allowedValue: "file-size" }, message: "must be equal to constant" }];
+              validate28.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;
@@ -2324,7 +2404,7 @@ function validate30(data, { instancePath = "", parentData, parentDataProperty, r
             if (data.device !== void 0) {
               const _errs4 = errors;
               if (typeof data.device !== "string") {
-                validate30.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                validate28.errors = [{ instancePath: instancePath + "/device", schemaPath: "#/properties/device/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                 return false;
               }
               var valid0 = _errs4 === errors;
@@ -2335,7 +2415,7 @@ function validate30(data, { instancePath = "", parentData, parentDataProperty, r
               if (data.file !== void 0) {
                 const _errs6 = errors;
                 if (typeof data.file !== "string") {
-                  validate30.errors = [{ instancePath: instancePath + "/file", schemaPath: "#/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                  validate28.errors = [{ instancePath: instancePath + "/file", schemaPath: "#/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
                   return false;
                 }
                 var valid0 = _errs6 === errors;
@@ -2347,7 +2427,7 @@ function validate30(data, { instancePath = "", parentData, parentDataProperty, r
                   let data3 = data.value;
                   const _errs8 = errors;
                   if (typeof data3 !== "string" && !(typeof data3 == "number" && isFinite(data3))) {
-                    validate30.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema24.type }, message: "must be string,number" }];
+                    validate28.errors = [{ instancePath: instancePath + "/value", schemaPath: "#/definitions/BigNumber/type", keyword: "type", params: { type: schema23.type }, message: "must be string,number" }];
                     return false;
                   }
                   var valid0 = _errs8 === errors;
@@ -2360,11 +2440,11 @@ function validate30(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate30.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      validate28.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
       return false;
     }
   }
-  validate30.errors = vErrors;
+  validate28.errors = vErrors;
   return errors === 0;
 }
 function validate11(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
@@ -2467,40 +2547,40 @@ function validate11(data, { instancePath = "", parentData, parentDataProperty, r
     valid0 = valid0 || _valid0;
     if (!valid0) {
       const _errs10 = errors;
-      if (!validate18(data, { instancePath, parentData, parentDataProperty, rootData })) {
-        vErrors = vErrors === null ? validate18.errors : vErrors.concat(validate18.errors);
+      if (!validate16(data, { instancePath, parentData, parentDataProperty, rootData })) {
+        vErrors = vErrors === null ? validate16.errors : vErrors.concat(validate16.errors);
         errors = vErrors.length;
       }
       var _valid0 = _errs10 === errors;
       valid0 = valid0 || _valid0;
       if (!valid0) {
         const _errs11 = errors;
-        if (!validate22(data, { instancePath, parentData, parentDataProperty, rootData })) {
-          vErrors = vErrors === null ? validate22.errors : vErrors.concat(validate22.errors);
+        if (!validate20(data, { instancePath, parentData, parentDataProperty, rootData })) {
+          vErrors = vErrors === null ? validate20.errors : vErrors.concat(validate20.errors);
           errors = vErrors.length;
         }
         var _valid0 = _errs11 === errors;
         valid0 = valid0 || _valid0;
         if (!valid0) {
           const _errs12 = errors;
-          if (!validate25(data, { instancePath, parentData, parentDataProperty, rootData })) {
-            vErrors = vErrors === null ? validate25.errors : vErrors.concat(validate25.errors);
+          if (!validate23(data, { instancePath, parentData, parentDataProperty, rootData })) {
+            vErrors = vErrors === null ? validate23.errors : vErrors.concat(validate23.errors);
             errors = vErrors.length;
           }
           var _valid0 = _errs12 === errors;
           valid0 = valid0 || _valid0;
           if (!valid0) {
             const _errs13 = errors;
-            if (!validate27(data, { instancePath, parentData, parentDataProperty, rootData })) {
-              vErrors = vErrors === null ? validate27.errors : vErrors.concat(validate27.errors);
+            if (!validate25(data, { instancePath, parentData, parentDataProperty, rootData })) {
+              vErrors = vErrors === null ? validate25.errors : vErrors.concat(validate25.errors);
               errors = vErrors.length;
             }
             var _valid0 = _errs13 === errors;
             valid0 = valid0 || _valid0;
             if (!valid0) {
               const _errs14 = errors;
-              if (!validate30(data, { instancePath, parentData, parentDataProperty, rootData })) {
-                vErrors = vErrors === null ? validate30.errors : vErrors.concat(validate30.errors);
+              if (!validate28(data, { instancePath, parentData, parentDataProperty, rootData })) {
+                vErrors = vErrors === null ? validate28.errors : vErrors.concat(validate28.errors);
                 errors = vErrors.length;
               }
               var _valid0 = _errs14 === errors;
@@ -2547,7 +2627,7 @@ function validate11(data, { instancePath = "", parentData, parentDataProperty, r
                             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" };
+                            const err9 = { instancePath: instancePath + "/type", schemaPath: "#/definitions/HashComponentMiscStringData/properties/type/enum", keyword: "enum", params: { allowedValues: schema35.properties.type.enum }, message: "must be equal to one of the allowed values" };
                             if (vErrors === null) {
                               vErrors = [err9];
                             } else {
@@ -2623,50 +2703,1360 @@ function validate11(data, { instancePath = "", parentData, parentDataProperty, r
 function validate33(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
   let vErrors = null;
   let errors = 0;
-  if (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.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;
+      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 _errs1 = errors;
+        const _errs4 = 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;
+          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);
             }
-            var valid0 = _errs2 === errors;
-          } else {
-            var valid0 = true;
+            errors++;
+            break;
           }
-          if (valid0) {
-            if (data.db !== void 0) {
-              const _errs3 = errors;
-              if (!validate13(data.db, { instancePath: instancePath + "/db", parentData: data, parentDataProperty: "db", rootData })) {
+        }
+        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 (!validate13(data, { instancePath, parentData, parentDataProperty, rootData })) {
+      vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.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++;
+    validate33.errors = vErrors;
+    return false;
+  } else {
+    errors = _errs0;
+    if (vErrors !== null) {
+      if (_errs0) {
+        vErrors.length = _errs0;
+      } else {
+        vErrors = null;
+      }
+    }
+  }
+  validate33.errors = vErrors;
+  return errors === 0;
+}
+function validate31(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (errors === 0) {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+      const _errs1 = errors;
+      for (const key0 in data) {
+        if (!(key0 === "pk" || key0 === "kek" || key0 === "db" || key0 === "dbx")) {
+          validate31.errors = [{ instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" }];
+          return false;
+        }
+      }
+      if (_errs1 === errors) {
+        if (data.pk !== void 0) {
+          let data0 = data.pk;
+          const _errs2 = errors;
+          const _errs3 = errors;
+          let valid1 = false;
+          const _errs4 = errors;
+          const _errs5 = errors;
+          if (errors === _errs5) {
+            if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+              let missing0;
+              if (data0.file === void 0 && (missing0 = "file") || data0.type === void 0 && (missing0 = "type")) {
+                const err0 = { instancePath: instancePath + "/pk", 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 _errs7 = errors;
+                for (const key1 in data0) {
+                  if (!(key1 === "type" || key1 === "file" || key1 === "offset" || key1 === "size")) {
+                    const err1 = { instancePath: instancePath + "/pk", schemaPath: "#/definitions/BinaryDataFromFile/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key1 }, message: "must NOT have additional properties" };
+                    if (vErrors === null) {
+                      vErrors = [err1];
+                    } else {
+                      vErrors.push(err1);
+                    }
+                    errors++;
+                    break;
+                  }
+                }
+                if (_errs7 === errors) {
+                  if (data0.type !== void 0) {
+                    let data1 = data0.type;
+                    const _errs8 = errors;
+                    if (typeof data1 !== "string") {
+                      const err2 = { instancePath: instancePath + "/pk/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" !== data1) {
+                      const err3 = { instancePath: instancePath + "/pk/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 valid3 = _errs8 === errors;
+                  } else {
+                    var valid3 = true;
+                  }
+                  if (valid3) {
+                    if (data0.file !== void 0) {
+                      const _errs10 = errors;
+                      if (typeof data0.file !== "string") {
+                        const err4 = { instancePath: instancePath + "/pk/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 valid3 = _errs10 === errors;
+                    } else {
+                      var valid3 = true;
+                    }
+                    if (valid3) {
+                      if (data0.offset !== void 0) {
+                        let data3 = data0.offset;
+                        const _errs12 = errors;
+                        if (!(typeof data3 == "number" && isFinite(data3))) {
+                          const err5 = { instancePath: instancePath + "/pk/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 valid3 = _errs12 === errors;
+                      } else {
+                        var valid3 = true;
+                      }
+                      if (valid3) {
+                        if (data0.size !== void 0) {
+                          let data4 = data0.size;
+                          const _errs14 = errors;
+                          if (!(typeof data4 == "number" && isFinite(data4))) {
+                            const err6 = { instancePath: instancePath + "/pk/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 valid3 = _errs14 === errors;
+                        } else {
+                          var valid3 = true;
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            } else {
+              const err7 = { instancePath: instancePath + "/pk", 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 = _errs4 === errors;
+          valid1 = valid1 || _valid0;
+          if (!valid1) {
+            const _errs16 = errors;
+            if (!validate13(data0, { instancePath: instancePath + "/pk", parentData: data, parentDataProperty: "pk", rootData })) {
+              vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+              errors = vErrors.length;
+            }
+            var _valid0 = _errs16 === errors;
+            valid1 = valid1 || _valid0;
+            if (!valid1) {
+              const _errs17 = errors;
+              const _errs18 = errors;
+              if (errors === _errs18) {
+                if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+                  let missing1;
+                  if (data0.buffer === void 0 && (missing1 = "buffer") || data0.type === void 0 && (missing1 = "type")) {
+                    const err8 = { instancePath: instancePath + "/pk", 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 _errs20 = errors;
+                    for (const key2 in data0) {
+                      if (!(key2 === "type" || key2 === "buffer")) {
+                        const err9 = { instancePath: instancePath + "/pk", schemaPath: "#/definitions/BinaryDataFromBuffer/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key2 }, message: "must NOT have additional properties" };
+                        if (vErrors === null) {
+                          vErrors = [err9];
+                        } else {
+                          vErrors.push(err9);
+                        }
+                        errors++;
+                        break;
+                      }
+                    }
+                    if (_errs20 === errors) {
+                      if (data0.type !== void 0) {
+                        let data5 = data0.type;
+                        const _errs21 = errors;
+                        if (typeof data5 !== "string") {
+                          const err10 = { instancePath: instancePath + "/pk/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" !== data5) {
+                          const err11 = { instancePath: instancePath + "/pk/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 valid5 = _errs21 === errors;
+                      } else {
+                        var valid5 = true;
+                      }
+                      if (valid5) {
+                        if (data0.buffer !== void 0) {
+                          let data6 = data0.buffer;
+                          const _errs23 = errors;
+                          if (!(data6 && typeof data6 == "object" && !Array.isArray(data6))) {
+                            const err12 = { instancePath: instancePath + "/pk/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 valid5 = _errs23 === errors;
+                        } else {
+                          var valid5 = true;
+                        }
+                      }
+                    }
+                  }
+                } else {
+                  const err13 = { instancePath: instancePath + "/pk", 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 = _errs17 === errors;
+              valid1 = valid1 || _valid0;
+              if (!valid1) {
+                const _errs25 = errors;
+                if (errors === _errs25) {
+                  if (Array.isArray(data0)) {
+                    var valid6 = true;
+                    const len0 = data0.length;
+                    for (let i0 = 0; i0 < len0; i0++) {
+                      const _errs27 = errors;
+                      if (!validate33(data0[i0], { instancePath: instancePath + "/pk/" + i0, parentData: data0, parentDataProperty: i0, rootData })) {
+                        vErrors = vErrors === null ? validate33.errors : vErrors.concat(validate33.errors);
+                        errors = vErrors.length;
+                      }
+                      var valid6 = _errs27 === errors;
+                      if (!valid6) {
+                        break;
+                      }
+                    }
+                  } else {
+                    const err14 = { instancePath: instancePath + "/pk", schemaPath: "#/properties/pk/anyOf/3/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                    if (vErrors === null) {
+                      vErrors = [err14];
+                    } else {
+                      vErrors.push(err14);
+                    }
+                    errors++;
+                  }
+                }
+                var _valid0 = _errs25 === errors;
+                valid1 = valid1 || _valid0;
+              }
+            }
+          }
+          if (!valid1) {
+            const err15 = { instancePath: instancePath + "/pk", schemaPath: "#/properties/pk/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+            if (vErrors === null) {
+              vErrors = [err15];
+            } else {
+              vErrors.push(err15);
+            }
+            errors++;
+            validate31.errors = vErrors;
+            return false;
+          } else {
+            errors = _errs3;
+            if (vErrors !== null) {
+              if (_errs3) {
+                vErrors.length = _errs3;
+              } else {
+                vErrors = null;
+              }
+            }
+          }
+          var valid0 = _errs2 === errors;
+        } else {
+          var valid0 = true;
+        }
+        if (valid0) {
+          if (data.kek !== void 0) {
+            let data8 = data.kek;
+            const _errs28 = errors;
+            const _errs29 = errors;
+            let valid7 = false;
+            const _errs30 = errors;
+            const _errs31 = errors;
+            if (errors === _errs31) {
+              if (data8 && typeof data8 == "object" && !Array.isArray(data8)) {
+                let missing2;
+                if (data8.file === void 0 && (missing2 = "file") || data8.type === void 0 && (missing2 = "type")) {
+                  const err16 = { instancePath: instancePath + "/kek", schemaPath: "#/definitions/BinaryDataFromFile/required", keyword: "required", params: { missingProperty: missing2 }, message: "must have required property '" + missing2 + "'" };
+                  if (vErrors === null) {
+                    vErrors = [err16];
+                  } else {
+                    vErrors.push(err16);
+                  }
+                  errors++;
+                } else {
+                  const _errs33 = errors;
+                  for (const key3 in data8) {
+                    if (!(key3 === "type" || key3 === "file" || key3 === "offset" || key3 === "size")) {
+                      const err17 = { instancePath: instancePath + "/kek", schemaPath: "#/definitions/BinaryDataFromFile/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key3 }, message: "must NOT have additional properties" };
+                      if (vErrors === null) {
+                        vErrors = [err17];
+                      } else {
+                        vErrors.push(err17);
+                      }
+                      errors++;
+                      break;
+                    }
+                  }
+                  if (_errs33 === errors) {
+                    if (data8.type !== void 0) {
+                      let data9 = data8.type;
+                      const _errs34 = errors;
+                      if (typeof data9 !== "string") {
+                        const err18 = { instancePath: instancePath + "/kek/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                        if (vErrors === null) {
+                          vErrors = [err18];
+                        } else {
+                          vErrors.push(err18);
+                        }
+                        errors++;
+                      }
+                      if ("file" !== data9) {
+                        const err19 = { instancePath: instancePath + "/kek/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/const", keyword: "const", params: { allowedValue: "file" }, message: "must be equal to constant" };
+                        if (vErrors === null) {
+                          vErrors = [err19];
+                        } else {
+                          vErrors.push(err19);
+                        }
+                        errors++;
+                      }
+                      var valid9 = _errs34 === errors;
+                    } else {
+                      var valid9 = true;
+                    }
+                    if (valid9) {
+                      if (data8.file !== void 0) {
+                        const _errs36 = errors;
+                        if (typeof data8.file !== "string") {
+                          const err20 = { instancePath: instancePath + "/kek/file", schemaPath: "#/definitions/BinaryDataFromFile/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                          if (vErrors === null) {
+                            vErrors = [err20];
+                          } else {
+                            vErrors.push(err20);
+                          }
+                          errors++;
+                        }
+                        var valid9 = _errs36 === errors;
+                      } else {
+                        var valid9 = true;
+                      }
+                      if (valid9) {
+                        if (data8.offset !== void 0) {
+                          let data11 = data8.offset;
+                          const _errs38 = errors;
+                          if (!(typeof data11 == "number" && isFinite(data11))) {
+                            const err21 = { instancePath: instancePath + "/kek/offset", schemaPath: "#/definitions/BinaryDataFromFile/properties/offset/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                            if (vErrors === null) {
+                              vErrors = [err21];
+                            } else {
+                              vErrors.push(err21);
+                            }
+                            errors++;
+                          }
+                          var valid9 = _errs38 === errors;
+                        } else {
+                          var valid9 = true;
+                        }
+                        if (valid9) {
+                          if (data8.size !== void 0) {
+                            let data12 = data8.size;
+                            const _errs40 = errors;
+                            if (!(typeof data12 == "number" && isFinite(data12))) {
+                              const err22 = { instancePath: instancePath + "/kek/size", schemaPath: "#/definitions/BinaryDataFromFile/properties/size/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                              if (vErrors === null) {
+                                vErrors = [err22];
+                              } else {
+                                vErrors.push(err22);
+                              }
+                              errors++;
+                            }
+                            var valid9 = _errs40 === errors;
+                          } else {
+                            var valid9 = true;
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              } else {
+                const err23 = { instancePath: instancePath + "/kek", schemaPath: "#/definitions/BinaryDataFromFile/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                if (vErrors === null) {
+                  vErrors = [err23];
+                } else {
+                  vErrors.push(err23);
+                }
+                errors++;
+              }
+            }
+            var _valid1 = _errs30 === errors;
+            valid7 = valid7 || _valid1;
+            if (!valid7) {
+              const _errs42 = errors;
+              if (!validate13(data8, { instancePath: instancePath + "/kek", parentData: data, parentDataProperty: "kek", rootData })) {
                 vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
                 errors = vErrors.length;
               }
-              var valid0 = _errs3 === errors;
+              var _valid1 = _errs42 === errors;
+              valid7 = valid7 || _valid1;
+              if (!valid7) {
+                const _errs43 = errors;
+                const _errs44 = errors;
+                if (errors === _errs44) {
+                  if (data8 && typeof data8 == "object" && !Array.isArray(data8)) {
+                    let missing3;
+                    if (data8.buffer === void 0 && (missing3 = "buffer") || data8.type === void 0 && (missing3 = "type")) {
+                      const err24 = { instancePath: instancePath + "/kek", schemaPath: "#/definitions/BinaryDataFromBuffer/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" };
+                      if (vErrors === null) {
+                        vErrors = [err24];
+                      } else {
+                        vErrors.push(err24);
+                      }
+                      errors++;
+                    } else {
+                      const _errs46 = errors;
+                      for (const key4 in data8) {
+                        if (!(key4 === "type" || key4 === "buffer")) {
+                          const err25 = { instancePath: instancePath + "/kek", schemaPath: "#/definitions/BinaryDataFromBuffer/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key4 }, message: "must NOT have additional properties" };
+                          if (vErrors === null) {
+                            vErrors = [err25];
+                          } else {
+                            vErrors.push(err25);
+                          }
+                          errors++;
+                          break;
+                        }
+                      }
+                      if (_errs46 === errors) {
+                        if (data8.type !== void 0) {
+                          let data13 = data8.type;
+                          const _errs47 = errors;
+                          if (typeof data13 !== "string") {
+                            const err26 = { instancePath: instancePath + "/kek/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                            if (vErrors === null) {
+                              vErrors = [err26];
+                            } else {
+                              vErrors.push(err26);
+                            }
+                            errors++;
+                          }
+                          if ("buffer" !== data13) {
+                            const err27 = { instancePath: instancePath + "/kek/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/const", keyword: "const", params: { allowedValue: "buffer" }, message: "must be equal to constant" };
+                            if (vErrors === null) {
+                              vErrors = [err27];
+                            } else {
+                              vErrors.push(err27);
+                            }
+                            errors++;
+                          }
+                          var valid11 = _errs47 === errors;
+                        } else {
+                          var valid11 = true;
+                        }
+                        if (valid11) {
+                          if (data8.buffer !== void 0) {
+                            let data14 = data8.buffer;
+                            const _errs49 = errors;
+                            if (!(data14 && typeof data14 == "object" && !Array.isArray(data14))) {
+                              const err28 = { instancePath: instancePath + "/kek/buffer", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/buffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                              if (vErrors === null) {
+                                vErrors = [err28];
+                              } else {
+                                vErrors.push(err28);
+                              }
+                              errors++;
+                            }
+                            var valid11 = _errs49 === errors;
+                          } else {
+                            var valid11 = true;
+                          }
+                        }
+                      }
+                    }
+                  } else {
+                    const err29 = { instancePath: instancePath + "/kek", schemaPath: "#/definitions/BinaryDataFromBuffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                    if (vErrors === null) {
+                      vErrors = [err29];
+                    } else {
+                      vErrors.push(err29);
+                    }
+                    errors++;
+                  }
+                }
+                var _valid1 = _errs43 === errors;
+                valid7 = valid7 || _valid1;
+                if (!valid7) {
+                  const _errs51 = errors;
+                  if (errors === _errs51) {
+                    if (Array.isArray(data8)) {
+                      var valid12 = true;
+                      const len1 = data8.length;
+                      for (let i1 = 0; i1 < len1; i1++) {
+                        const _errs53 = errors;
+                        if (!validate33(data8[i1], { instancePath: instancePath + "/kek/" + i1, parentData: data8, parentDataProperty: i1, rootData })) {
+                          vErrors = vErrors === null ? validate33.errors : vErrors.concat(validate33.errors);
+                          errors = vErrors.length;
+                        }
+                        var valid12 = _errs53 === errors;
+                        if (!valid12) {
+                          break;
+                        }
+                      }
+                    } else {
+                      const err30 = { instancePath: instancePath + "/kek", schemaPath: "#/properties/kek/anyOf/3/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                      if (vErrors === null) {
+                        vErrors = [err30];
+                      } else {
+                        vErrors.push(err30);
+                      }
+                      errors++;
+                    }
+                  }
+                  var _valid1 = _errs51 === errors;
+                  valid7 = valid7 || _valid1;
+                }
+              }
+            }
+            if (!valid7) {
+              const err31 = { instancePath: instancePath + "/kek", schemaPath: "#/properties/kek/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+              if (vErrors === null) {
+                vErrors = [err31];
+              } else {
+                vErrors.push(err31);
+              }
+              errors++;
+              validate31.errors = vErrors;
+              return false;
+            } else {
+              errors = _errs29;
+              if (vErrors !== null) {
+                if (_errs29) {
+                  vErrors.length = _errs29;
+                } else {
+                  vErrors = null;
+                }
+              }
+            }
+            var valid0 = _errs28 === errors;
+          } else {
+            var valid0 = true;
+          }
+          if (valid0) {
+            if (data.db !== void 0) {
+              let data16 = data.db;
+              const _errs54 = errors;
+              const _errs55 = errors;
+              let valid13 = false;
+              const _errs56 = errors;
+              const _errs57 = errors;
+              if (errors === _errs57) {
+                if (data16 && typeof data16 == "object" && !Array.isArray(data16)) {
+                  let missing4;
+                  if (data16.file === void 0 && (missing4 = "file") || data16.type === void 0 && (missing4 = "type")) {
+                    const err32 = { instancePath: instancePath + "/db", schemaPath: "#/definitions/BinaryDataFromFile/required", keyword: "required", params: { missingProperty: missing4 }, message: "must have required property '" + missing4 + "'" };
+                    if (vErrors === null) {
+                      vErrors = [err32];
+                    } else {
+                      vErrors.push(err32);
+                    }
+                    errors++;
+                  } else {
+                    const _errs59 = errors;
+                    for (const key5 in data16) {
+                      if (!(key5 === "type" || key5 === "file" || key5 === "offset" || key5 === "size")) {
+                        const err33 = { instancePath: instancePath + "/db", schemaPath: "#/definitions/BinaryDataFromFile/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key5 }, message: "must NOT have additional properties" };
+                        if (vErrors === null) {
+                          vErrors = [err33];
+                        } else {
+                          vErrors.push(err33);
+                        }
+                        errors++;
+                        break;
+                      }
+                    }
+                    if (_errs59 === errors) {
+                      if (data16.type !== void 0) {
+                        let data17 = data16.type;
+                        const _errs60 = errors;
+                        if (typeof data17 !== "string") {
+                          const err34 = { instancePath: instancePath + "/db/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                          if (vErrors === null) {
+                            vErrors = [err34];
+                          } else {
+                            vErrors.push(err34);
+                          }
+                          errors++;
+                        }
+                        if ("file" !== data17) {
+                          const err35 = { instancePath: instancePath + "/db/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/const", keyword: "const", params: { allowedValue: "file" }, message: "must be equal to constant" };
+                          if (vErrors === null) {
+                            vErrors = [err35];
+                          } else {
+                            vErrors.push(err35);
+                          }
+                          errors++;
+                        }
+                        var valid15 = _errs60 === errors;
+                      } else {
+                        var valid15 = true;
+                      }
+                      if (valid15) {
+                        if (data16.file !== void 0) {
+                          const _errs62 = errors;
+                          if (typeof data16.file !== "string") {
+                            const err36 = { instancePath: instancePath + "/db/file", schemaPath: "#/definitions/BinaryDataFromFile/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                            if (vErrors === null) {
+                              vErrors = [err36];
+                            } else {
+                              vErrors.push(err36);
+                            }
+                            errors++;
+                          }
+                          var valid15 = _errs62 === errors;
+                        } else {
+                          var valid15 = true;
+                        }
+                        if (valid15) {
+                          if (data16.offset !== void 0) {
+                            let data19 = data16.offset;
+                            const _errs64 = errors;
+                            if (!(typeof data19 == "number" && isFinite(data19))) {
+                              const err37 = { instancePath: instancePath + "/db/offset", schemaPath: "#/definitions/BinaryDataFromFile/properties/offset/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                              if (vErrors === null) {
+                                vErrors = [err37];
+                              } else {
+                                vErrors.push(err37);
+                              }
+                              errors++;
+                            }
+                            var valid15 = _errs64 === errors;
+                          } else {
+                            var valid15 = true;
+                          }
+                          if (valid15) {
+                            if (data16.size !== void 0) {
+                              let data20 = data16.size;
+                              const _errs66 = errors;
+                              if (!(typeof data20 == "number" && isFinite(data20))) {
+                                const err38 = { instancePath: instancePath + "/db/size", schemaPath: "#/definitions/BinaryDataFromFile/properties/size/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                if (vErrors === null) {
+                                  vErrors = [err38];
+                                } else {
+                                  vErrors.push(err38);
+                                }
+                                errors++;
+                              }
+                              var valid15 = _errs66 === errors;
+                            } else {
+                              var valid15 = true;
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                } else {
+                  const err39 = { instancePath: instancePath + "/db", schemaPath: "#/definitions/BinaryDataFromFile/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                  if (vErrors === null) {
+                    vErrors = [err39];
+                  } else {
+                    vErrors.push(err39);
+                  }
+                  errors++;
+                }
+              }
+              var _valid2 = _errs56 === errors;
+              valid13 = valid13 || _valid2;
+              if (!valid13) {
+                const _errs68 = errors;
+                if (!validate13(data16, { instancePath: instancePath + "/db", parentData: data, parentDataProperty: "db", rootData })) {
+                  vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+                  errors = vErrors.length;
+                }
+                var _valid2 = _errs68 === errors;
+                valid13 = valid13 || _valid2;
+                if (!valid13) {
+                  const _errs69 = errors;
+                  const _errs70 = errors;
+                  if (errors === _errs70) {
+                    if (data16 && typeof data16 == "object" && !Array.isArray(data16)) {
+                      let missing5;
+                      if (data16.buffer === void 0 && (missing5 = "buffer") || data16.type === void 0 && (missing5 = "type")) {
+                        const err40 = { instancePath: instancePath + "/db", schemaPath: "#/definitions/BinaryDataFromBuffer/required", keyword: "required", params: { missingProperty: missing5 }, message: "must have required property '" + missing5 + "'" };
+                        if (vErrors === null) {
+                          vErrors = [err40];
+                        } else {
+                          vErrors.push(err40);
+                        }
+                        errors++;
+                      } else {
+                        const _errs72 = errors;
+                        for (const key6 in data16) {
+                          if (!(key6 === "type" || key6 === "buffer")) {
+                            const err41 = { instancePath: instancePath + "/db", schemaPath: "#/definitions/BinaryDataFromBuffer/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key6 }, message: "must NOT have additional properties" };
+                            if (vErrors === null) {
+                              vErrors = [err41];
+                            } else {
+                              vErrors.push(err41);
+                            }
+                            errors++;
+                            break;
+                          }
+                        }
+                        if (_errs72 === errors) {
+                          if (data16.type !== void 0) {
+                            let data21 = data16.type;
+                            const _errs73 = errors;
+                            if (typeof data21 !== "string") {
+                              const err42 = { instancePath: instancePath + "/db/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                              if (vErrors === null) {
+                                vErrors = [err42];
+                              } else {
+                                vErrors.push(err42);
+                              }
+                              errors++;
+                            }
+                            if ("buffer" !== data21) {
+                              const err43 = { instancePath: instancePath + "/db/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/const", keyword: "const", params: { allowedValue: "buffer" }, message: "must be equal to constant" };
+                              if (vErrors === null) {
+                                vErrors = [err43];
+                              } else {
+                                vErrors.push(err43);
+                              }
+                              errors++;
+                            }
+                            var valid17 = _errs73 === errors;
+                          } else {
+                            var valid17 = true;
+                          }
+                          if (valid17) {
+                            if (data16.buffer !== void 0) {
+                              let data22 = data16.buffer;
+                              const _errs75 = errors;
+                              if (!(data22 && typeof data22 == "object" && !Array.isArray(data22))) {
+                                const err44 = { instancePath: instancePath + "/db/buffer", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/buffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                                if (vErrors === null) {
+                                  vErrors = [err44];
+                                } else {
+                                  vErrors.push(err44);
+                                }
+                                errors++;
+                              }
+                              var valid17 = _errs75 === errors;
+                            } else {
+                              var valid17 = true;
+                            }
+                          }
+                        }
+                      }
+                    } else {
+                      const err45 = { instancePath: instancePath + "/db", schemaPath: "#/definitions/BinaryDataFromBuffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                      if (vErrors === null) {
+                        vErrors = [err45];
+                      } else {
+                        vErrors.push(err45);
+                      }
+                      errors++;
+                    }
+                  }
+                  var _valid2 = _errs69 === errors;
+                  valid13 = valid13 || _valid2;
+                  if (!valid13) {
+                    const _errs77 = errors;
+                    if (errors === _errs77) {
+                      if (Array.isArray(data16)) {
+                        var valid18 = true;
+                        const len2 = data16.length;
+                        for (let i2 = 0; i2 < len2; i2++) {
+                          const _errs79 = errors;
+                          if (!validate33(data16[i2], { instancePath: instancePath + "/db/" + i2, parentData: data16, parentDataProperty: i2, rootData })) {
+                            vErrors = vErrors === null ? validate33.errors : vErrors.concat(validate33.errors);
+                            errors = vErrors.length;
+                          }
+                          var valid18 = _errs79 === errors;
+                          if (!valid18) {
+                            break;
+                          }
+                        }
+                      } else {
+                        const err46 = { instancePath: instancePath + "/db", schemaPath: "#/properties/db/anyOf/3/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                        if (vErrors === null) {
+                          vErrors = [err46];
+                        } else {
+                          vErrors.push(err46);
+                        }
+                        errors++;
+                      }
+                    }
+                    var _valid2 = _errs77 === errors;
+                    valid13 = valid13 || _valid2;
+                  }
+                }
+              }
+              if (!valid13) {
+                const err47 = { instancePath: instancePath + "/db", schemaPath: "#/properties/db/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                if (vErrors === null) {
+                  vErrors = [err47];
+                } else {
+                  vErrors.push(err47);
+                }
+                errors++;
+                validate31.errors = vErrors;
+                return false;
+              } else {
+                errors = _errs55;
+                if (vErrors !== null) {
+                  if (_errs55) {
+                    vErrors.length = _errs55;
+                  } else {
+                    vErrors = null;
+                  }
+                }
+              }
+              var valid0 = _errs54 === 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;
+              if (data.dbx !== void 0) {
+                let data24 = data.dbx;
+                const _errs80 = errors;
+                const _errs81 = errors;
+                let valid19 = false;
+                const _errs82 = errors;
+                const _errs83 = errors;
+                if (errors === _errs83) {
+                  if (data24 && typeof data24 == "object" && !Array.isArray(data24)) {
+                    let missing6;
+                    if (data24.file === void 0 && (missing6 = "file") || data24.type === void 0 && (missing6 = "type")) {
+                      const err48 = { instancePath: instancePath + "/dbx", schemaPath: "#/definitions/BinaryDataFromFile/required", keyword: "required", params: { missingProperty: missing6 }, message: "must have required property '" + missing6 + "'" };
+                      if (vErrors === null) {
+                        vErrors = [err48];
+                      } else {
+                        vErrors.push(err48);
+                      }
+                      errors++;
+                    } else {
+                      const _errs85 = errors;
+                      for (const key7 in data24) {
+                        if (!(key7 === "type" || key7 === "file" || key7 === "offset" || key7 === "size")) {
+                          const err49 = { instancePath: instancePath + "/dbx", schemaPath: "#/definitions/BinaryDataFromFile/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key7 }, message: "must NOT have additional properties" };
+                          if (vErrors === null) {
+                            vErrors = [err49];
+                          } else {
+                            vErrors.push(err49);
+                          }
+                          errors++;
+                          break;
+                        }
+                      }
+                      if (_errs85 === errors) {
+                        if (data24.type !== void 0) {
+                          let data25 = data24.type;
+                          const _errs86 = errors;
+                          if (typeof data25 !== "string") {
+                            const err50 = { instancePath: instancePath + "/dbx/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                            if (vErrors === null) {
+                              vErrors = [err50];
+                            } else {
+                              vErrors.push(err50);
+                            }
+                            errors++;
+                          }
+                          if ("file" !== data25) {
+                            const err51 = { instancePath: instancePath + "/dbx/type", schemaPath: "#/definitions/BinaryDataFromFile/properties/type/const", keyword: "const", params: { allowedValue: "file" }, message: "must be equal to constant" };
+                            if (vErrors === null) {
+                              vErrors = [err51];
+                            } else {
+                              vErrors.push(err51);
+                            }
+                            errors++;
+                          }
+                          var valid21 = _errs86 === errors;
+                        } else {
+                          var valid21 = true;
+                        }
+                        if (valid21) {
+                          if (data24.file !== void 0) {
+                            const _errs88 = errors;
+                            if (typeof data24.file !== "string") {
+                              const err52 = { instancePath: instancePath + "/dbx/file", schemaPath: "#/definitions/BinaryDataFromFile/properties/file/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                              if (vErrors === null) {
+                                vErrors = [err52];
+                              } else {
+                                vErrors.push(err52);
+                              }
+                              errors++;
+                            }
+                            var valid21 = _errs88 === errors;
+                          } else {
+                            var valid21 = true;
+                          }
+                          if (valid21) {
+                            if (data24.offset !== void 0) {
+                              let data27 = data24.offset;
+                              const _errs90 = errors;
+                              if (!(typeof data27 == "number" && isFinite(data27))) {
+                                const err53 = { instancePath: instancePath + "/dbx/offset", schemaPath: "#/definitions/BinaryDataFromFile/properties/offset/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                if (vErrors === null) {
+                                  vErrors = [err53];
+                                } else {
+                                  vErrors.push(err53);
+                                }
+                                errors++;
+                              }
+                              var valid21 = _errs90 === errors;
+                            } else {
+                              var valid21 = true;
+                            }
+                            if (valid21) {
+                              if (data24.size !== void 0) {
+                                let data28 = data24.size;
+                                const _errs92 = errors;
+                                if (!(typeof data28 == "number" && isFinite(data28))) {
+                                  const err54 = { instancePath: instancePath + "/dbx/size", schemaPath: "#/definitions/BinaryDataFromFile/properties/size/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                                  if (vErrors === null) {
+                                    vErrors = [err54];
+                                  } else {
+                                    vErrors.push(err54);
+                                  }
+                                  errors++;
+                                }
+                                var valid21 = _errs92 === errors;
+                              } else {
+                                var valid21 = true;
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  } else {
+                    const err55 = { instancePath: instancePath + "/dbx", schemaPath: "#/definitions/BinaryDataFromFile/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                    if (vErrors === null) {
+                      vErrors = [err55];
+                    } else {
+                      vErrors.push(err55);
+                    }
+                    errors++;
+                  }
+                }
+                var _valid3 = _errs82 === errors;
+                valid19 = valid19 || _valid3;
+                if (!valid19) {
+                  const _errs94 = errors;
+                  if (!validate13(data24, { instancePath: instancePath + "/dbx", parentData: data, parentDataProperty: "dbx", rootData })) {
+                    vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);
+                    errors = vErrors.length;
+                  }
+                  var _valid3 = _errs94 === errors;
+                  valid19 = valid19 || _valid3;
+                  if (!valid19) {
+                    const _errs95 = errors;
+                    const _errs96 = errors;
+                    if (errors === _errs96) {
+                      if (data24 && typeof data24 == "object" && !Array.isArray(data24)) {
+                        let missing7;
+                        if (data24.buffer === void 0 && (missing7 = "buffer") || data24.type === void 0 && (missing7 = "type")) {
+                          const err56 = { instancePath: instancePath + "/dbx", schemaPath: "#/definitions/BinaryDataFromBuffer/required", keyword: "required", params: { missingProperty: missing7 }, message: "must have required property '" + missing7 + "'" };
+                          if (vErrors === null) {
+                            vErrors = [err56];
+                          } else {
+                            vErrors.push(err56);
+                          }
+                          errors++;
+                        } else {
+                          const _errs98 = errors;
+                          for (const key8 in data24) {
+                            if (!(key8 === "type" || key8 === "buffer")) {
+                              const err57 = { instancePath: instancePath + "/dbx", schemaPath: "#/definitions/BinaryDataFromBuffer/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key8 }, message: "must NOT have additional properties" };
+                              if (vErrors === null) {
+                                vErrors = [err57];
+                              } else {
+                                vErrors.push(err57);
+                              }
+                              errors++;
+                              break;
+                            }
+                          }
+                          if (_errs98 === errors) {
+                            if (data24.type !== void 0) {
+                              let data29 = data24.type;
+                              const _errs99 = errors;
+                              if (typeof data29 !== "string") {
+                                const err58 = { instancePath: instancePath + "/dbx/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                if (vErrors === null) {
+                                  vErrors = [err58];
+                                } else {
+                                  vErrors.push(err58);
+                                }
+                                errors++;
+                              }
+                              if ("buffer" !== data29) {
+                                const err59 = { instancePath: instancePath + "/dbx/type", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/type/const", keyword: "const", params: { allowedValue: "buffer" }, message: "must be equal to constant" };
+                                if (vErrors === null) {
+                                  vErrors = [err59];
+                                } else {
+                                  vErrors.push(err59);
+                                }
+                                errors++;
+                              }
+                              var valid23 = _errs99 === errors;
+                            } else {
+                              var valid23 = true;
+                            }
+                            if (valid23) {
+                              if (data24.buffer !== void 0) {
+                                let data30 = data24.buffer;
+                                const _errs101 = errors;
+                                if (!(data30 && typeof data30 == "object" && !Array.isArray(data30))) {
+                                  const err60 = { instancePath: instancePath + "/dbx/buffer", schemaPath: "#/definitions/BinaryDataFromBuffer/properties/buffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                                  if (vErrors === null) {
+                                    vErrors = [err60];
+                                  } else {
+                                    vErrors.push(err60);
+                                  }
+                                  errors++;
+                                }
+                                var valid23 = _errs101 === errors;
+                              } else {
+                                var valid23 = true;
+                              }
+                            }
+                          }
+                        }
+                      } else {
+                        const err61 = { instancePath: instancePath + "/dbx", schemaPath: "#/definitions/BinaryDataFromBuffer/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                        if (vErrors === null) {
+                          vErrors = [err61];
+                        } else {
+                          vErrors.push(err61);
+                        }
+                        errors++;
+                      }
+                    }
+                    var _valid3 = _errs95 === errors;
+                    valid19 = valid19 || _valid3;
+                    if (!valid19) {
+                      const _errs103 = errors;
+                      if (errors === _errs103) {
+                        if (Array.isArray(data24)) {
+                          var valid24 = true;
+                          const len3 = data24.length;
+                          for (let i3 = 0; i3 < len3; i3++) {
+                            const _errs105 = errors;
+                            if (!validate33(data24[i3], { instancePath: instancePath + "/dbx/" + i3, parentData: data24, parentDataProperty: i3, rootData })) {
+                              vErrors = vErrors === null ? validate33.errors : vErrors.concat(validate33.errors);
+                              errors = vErrors.length;
+                            }
+                            var valid24 = _errs105 === errors;
+                            if (!valid24) {
+                              break;
+                            }
+                          }
+                        } else {
+                          const err62 = { instancePath: instancePath + "/dbx", schemaPath: "#/properties/dbx/anyOf/3/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+                          if (vErrors === null) {
+                            vErrors = [err62];
+                          } else {
+                            vErrors.push(err62);
+                          }
+                          errors++;
+                        }
+                      }
+                      var _valid3 = _errs103 === errors;
+                      valid19 = valid19 || _valid3;
+                    }
+                  }
+                }
+                if (!valid19) {
+                  const err63 = { instancePath: instancePath + "/dbx", schemaPath: "#/properties/dbx/anyOf", keyword: "anyOf", params: {}, message: "must match a schema in anyOf" };
+                  if (vErrors === null) {
+                    vErrors = [err63];
+                  } else {
+                    vErrors.push(err63);
+                  }
+                  errors++;
+                  validate31.errors = vErrors;
+                  return false;
+                } else {
+                  errors = _errs81;
+                  if (vErrors !== null) {
+                    if (_errs81) {
+                      vErrors.length = _errs81;
+                    } else {
+                      vErrors = null;
+                    }
+                  }
                 }
-                var valid0 = _errs4 === errors;
+                var valid0 = _errs80 === errors;
               } else {
                 var valid0 = true;
               }
@@ -2675,11 +4065,11 @@ function validate33(data, { instancePath = "", parentData, parentDataProperty, r
         }
       }
     } else {
-      validate33.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+      validate31.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
       return false;
     }
   }
-  validate33.errors = vErrors;
+  validate31.errors = vErrors;
   return errors === 0;
 }
 function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
@@ -2818,8 +4208,8 @@ function validate10(data, { instancePath = "", parentData, parentDataProperty, r
                           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);
+                              if (!validate31(data.enrollSecureBoot, { instancePath: instancePath + "/enrollSecureBoot", parentData: data, parentDataProperty: "enrollSecureBoot", rootData })) {
+                                vErrors = vErrors === null ? validate31.errors : vErrors.concat(validate31.errors);
                                 errors = vErrors.length;
                               }
                               var valid0 = _errs21 === errors;
@@ -2883,7 +4273,7 @@ const build = async (config) => {
       await genCode(config);
     }
     if (!config.skipExtract) {
-      const extract = (await import("./extract-BvhlZgSs.js")).extract;
+      const extract = (await import("./extract-DWqQqF9y.js")).extract;
       await extract(config.buildFolder);
     }
     if (!config.skipMake) {
@@ -2903,5 +4293,9 @@ const build = async (config) => {
   }
 };
 export {
-  build as b
+  EFI_VAR_DB as E,
+  EFI_VAR_DBX as a,
+  build as b,
+  EFI_VAR_KEK as c,
+  EFI_VAR_PK as d
 };