@sjcrh/proteinpaint-types 2.86.0 → 2.87.1

package/dist/chunk-QDIIM52V.js

@@ -0,0 +1,165 @@
+import {
+  __toESM,
+  require_lib
+} from "./chunk-Z6B6IQIY.js";
+
+// dist/termdb.singleSampleMutation.ts
+var import_typia = __toESM(require_lib(), 1);
+
+// src/routes/termdb.singleSampleMutation.ts
+var termdbSingleSampleMutationPayload = {
+  request: {
+    typeId: "TermdbSingleSampleMutationRequest"
+  },
+  response: {
+    typeId: "TermdbSingleSampleMutationResponse"
+  }
+  // examples: []
+};
+
+// dist/termdb.singleSampleMutation.ts
+var validTermdbSingleSampleMutationRequest = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    return "object" === typeof input2 && null !== input2 && ("string" === typeof input2.genome && "string" === typeof input2.dslabel && "string" === typeof input2.sample);
+  };
+  if (false === __is(input)) {
+    const $report = import_typia.createValidate.report(errors);
+    ((input2, _path, _exceptionable = true) => {
+      const $vo0 = (input3, _path2, _exceptionable2 = true) => ["string" === typeof input3.genome || $report(_exceptionable2, {
+        path: _path2 + ".genome",
+        expected: "string",
+        value: input3.genome
+      }), "string" === typeof input3.dslabel || $report(_exceptionable2, {
+        path: _path2 + ".dslabel",
+        expected: "string",
+        value: input3.dslabel
+      }), "string" === typeof input3.sample || $report(_exceptionable2, {
+        path: _path2 + ".sample",
+        expected: "string",
+        value: input3.sample
+      })].every((flag) => flag);
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: "TermdbSingleSampleMutationRequest",
+        value: input2
+      })) && $vo0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: "TermdbSingleSampleMutationRequest",
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+var validTermdbSingleSampleMutationResponse = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    const $io0 = (input3) => "number" === typeof input3.status && "string" === typeof input3.error;
+    const $io1 = (input3) => Array.isArray(input3.mlst) && input3.mlst.every((elem) => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && $io2(elem)) && (void 0 === input3.dt2total || Array.isArray(input3.dt2total) && input3.dt2total.every((elem) => "object" === typeof elem && null !== elem && $io3(elem)));
+    const $io2 = (input3) => true;
+    const $io3 = (input3) => "number" === typeof input3.dt && "number" === typeof input3.total;
+    const $iu0 = (input3) => (() => {
+      if (void 0 !== input3.status)
+        return $io0(input3);
+      if (void 0 !== input3.mlst)
+        return $io1(input3);
+      return false;
+    })();
+    return "object" === typeof input2 && null !== input2 && $iu0(input2);
+  };
+  if (false === __is(input)) {
+    const $report = import_typia.createValidate.report(errors);
+    ((input2, _path, _exceptionable = true) => {
+      const $vo0 = (input3, _path2, _exceptionable2 = true) => ["number" === typeof input3.status || $report(_exceptionable2, {
+        path: _path2 + ".status",
+        expected: "number",
+        value: input3.status
+      }), "string" === typeof input3.error || $report(_exceptionable2, {
+        path: _path2 + ".error",
+        expected: "string",
+        value: input3.error
+      })].every((flag) => flag);
+      const $vo1 = (input3, _path2, _exceptionable2 = true) => [(Array.isArray(input3.mlst) || $report(_exceptionable2, {
+        path: _path2 + ".mlst",
+        expected: "Array<object>",
+        value: input3.mlst
+      })) && input3.mlst.map((elem, _index1) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || $report(_exceptionable2, {
+        path: _path2 + ".mlst[" + _index1 + "]",
+        expected: "object",
+        value: elem
+      })) && $vo2(elem, _path2 + ".mlst[" + _index1 + "]", _exceptionable2) || $report(_exceptionable2, {
+        path: _path2 + ".mlst[" + _index1 + "]",
+        expected: "object",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".mlst",
+        expected: "Array<object>",
+        value: input3.mlst
+      }), void 0 === input3.dt2total || (Array.isArray(input3.dt2total) || $report(_exceptionable2, {
+        path: _path2 + ".dt2total",
+        expected: "(Array<__type> | undefined)",
+        value: input3.dt2total
+      })) && input3.dt2total.map((elem, _index2) => ("object" === typeof elem && null !== elem || $report(_exceptionable2, {
+        path: _path2 + ".dt2total[" + _index2 + "]",
+        expected: "__type",
+        value: elem
+      })) && $vo3(elem, _path2 + ".dt2total[" + _index2 + "]", _exceptionable2) || $report(_exceptionable2, {
+        path: _path2 + ".dt2total[" + _index2 + "]",
+        expected: "__type",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".dt2total",
+        expected: "(Array<__type> | undefined)",
+        value: input3.dt2total
+      })].every((flag) => flag);
+      const $vo2 = (input3, _path2, _exceptionable2 = true) => true;
+      const $vo3 = (input3, _path2, _exceptionable2 = true) => ["number" === typeof input3.dt || $report(_exceptionable2, {
+        path: _path2 + ".dt",
+        expected: "number",
+        value: input3.dt
+      }), "number" === typeof input3.total || $report(_exceptionable2, {
+        path: _path2 + ".total",
+        expected: "number",
+        value: input3.total
+      })].every((flag) => flag);
+      const $vu0 = (input3, _path2, _exceptionable2 = true) => (() => {
+        if (void 0 !== input3.status)
+          return $vo0(input3, _path2, _exceptionable2);
+        if (void 0 !== input3.mlst)
+          return $vo1(input3, _path2, _exceptionable2);
+        return $report(_exceptionable2, {
+          path: _path2,
+          expected: "(ErrorResponse | ValidResponse)",
+          value: input3
+        });
+      })();
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: "(ErrorResponse | ValidResponse)",
+        value: input2
+      })) && $vu0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: "(ErrorResponse | ValidResponse)",
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+
+export {
+  termdbSingleSampleMutationPayload,
+  validTermdbSingleSampleMutationRequest,
+  validTermdbSingleSampleMutationResponse
+};

package/dist/chunk-QX7QLUKY.js

@@ -0,0 +1,228 @@
+import {
+  __toESM,
+  require_lib
+} from "./chunk-Z6B6IQIY.js";
+
+// dist/hicstat.ts
+var import_typia = __toESM(require_lib(), 1);
+
+// src/routes/hicstat.ts
+var hicstatPayload = {
+  request: {
+    typeId: "HicstatRequest"
+  },
+  response: {
+    typeId: "HicstatResponse"
+  }
+  // examples: []
+};
+
+// dist/hicstat.ts
+var validHicstatRequest = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    const $io0 = (input3) => "string" === typeof input3.file && (null !== input3.url && void 0 === input3.url);
+    const $io1 = (input3) => null !== input3.file && void 0 === input3.file && "string" === typeof input3.url;
+    const $iu0 = (input3) => (() => {
+      if ("string" === typeof input3.url)
+        return $io1(input3);
+      if ("string" === typeof input3.file)
+        return $io0(input3);
+      return false;
+    })();
+    return "object" === typeof input2 && null !== input2 && $iu0(input2);
+  };
+  if (false === __is(input)) {
+    const $report = import_typia.createValidate.report(errors);
+    ((input2, _path, _exceptionable = true) => {
+      const $vo0 = (input3, _path2, _exceptionable2 = true) => ["string" === typeof input3.file || $report(_exceptionable2, {
+        path: _path2 + ".file",
+        expected: "string",
+        value: input3.file
+      }), (null !== input3.url || $report(_exceptionable2, {
+        path: _path2 + ".url",
+        expected: "undefined",
+        value: input3.url
+      })) && (void 0 === input3.url || $report(_exceptionable2, {
+        path: _path2 + ".url",
+        expected: "undefined",
+        value: input3.url
+      }))].every((flag) => flag);
+      const $vo1 = (input3, _path2, _exceptionable2 = true) => [(null !== input3.file || $report(_exceptionable2, {
+        path: _path2 + ".file",
+        expected: "undefined",
+        value: input3.file
+      })) && (void 0 === input3.file || $report(_exceptionable2, {
+        path: _path2 + ".file",
+        expected: "undefined",
+        value: input3.file
+      })), "string" === typeof input3.url || $report(_exceptionable2, {
+        path: _path2 + ".url",
+        expected: "string",
+        value: input3.url
+      })].every((flag) => flag);
+      const $vu0 = (input3, _path2, _exceptionable2 = true) => (() => {
+        if ("string" === typeof input3.url)
+          return $vo1(input3, _path2, _exceptionable2);
+        if ("string" === typeof input3.file)
+          return $vo0(input3, _path2, _exceptionable2);
+        return $report(_exceptionable2, {
+          path: _path2,
+          expected: "(HicstatRequestWithUrl | HicstatRequestWithFile)",
+          value: input3
+        });
+      })();
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: "(HicstatRequestWithFile | HicstatRequestWithUrl)",
+        value: input2
+      })) && $vu0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: "(HicstatRequestWithFile | HicstatRequestWithUrl)",
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+var validHicstatResponse = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    const $join = import_typia.createValidate.join;
+    const $io0 = (input3) => (7 === input3.version || 8 === input3.version || 9 === input3.version) && "string" === typeof input3["Genome ID"] && ("object" === typeof input3.Chromosomes && null !== input3.Chromosomes && $io1(input3.Chromosomes)) && (Array.isArray(input3.chrorder) && input3.chrorder.every((elem) => "number" === typeof elem)) && (Array.isArray(input3["Base pair-delimited resolutions"]) && input3["Base pair-delimited resolutions"].every((elem) => "number" === typeof elem)) && (Array.isArray(input3["Fragment-delimited resolutions"]) && input3["Fragment-delimited resolutions"].every((elem) => "number" === typeof elem)) && (Array.isArray(input3.normalization) && input3.normalization.every((elem) => "string" === typeof elem));
+    const $io1 = (input3) => "number" === typeof input3.All && "number" === typeof input3.X && "number" === typeof input3.Y && "number" === typeof input3.M && Object.keys(input3).every((key) => {
+      const value = input3[key];
+      if (void 0 === value)
+        return true;
+      if (RegExp(/^-?\d+\.?\d*$/).test(key))
+        return "number" === typeof value;
+      return true;
+    });
+    return "object" === typeof input2 && null !== input2 && $io0(input2);
+  };
+  if (false === __is(input)) {
+    const $report = import_typia.createValidate.report(errors);
+    ((input2, _path, _exceptionable = true) => {
+      const $join = import_typia.createValidate.join;
+      const $vo0 = (input3, _path2, _exceptionable2 = true) => [7 === input3.version || 8 === input3.version || 9 === input3.version || $report(_exceptionable2, {
+        path: _path2 + ".version",
+        expected: "(7 | 8 | 9)",
+        value: input3.version
+      }), "string" === typeof input3["Genome ID"] || $report(_exceptionable2, {
+        path: _path2 + '["Genome ID"]',
+        expected: "string",
+        value: input3["Genome ID"]
+      }), ("object" === typeof input3.Chromosomes && null !== input3.Chromosomes || $report(_exceptionable2, {
+        path: _path2 + ".Chromosomes",
+        expected: "__type",
+        value: input3.Chromosomes
+      })) && $vo1(input3.Chromosomes, _path2 + ".Chromosomes", _exceptionable2) || $report(_exceptionable2, {
+        path: _path2 + ".Chromosomes",
+        expected: "__type",
+        value: input3.Chromosomes
+      }), (Array.isArray(input3.chrorder) || $report(_exceptionable2, {
+        path: _path2 + ".chrorder",
+        expected: "Array<number>",
+        value: input3.chrorder
+      })) && input3.chrorder.map((elem, _index1) => "number" === typeof elem || $report(_exceptionable2, {
+        path: _path2 + ".chrorder[" + _index1 + "]",
+        expected: "number",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".chrorder",
+        expected: "Array<number>",
+        value: input3.chrorder
+      }), (Array.isArray(input3["Base pair-delimited resolutions"]) || $report(_exceptionable2, {
+        path: _path2 + '["Base pair-delimited resolutions"]',
+        expected: "Array<number>",
+        value: input3["Base pair-delimited resolutions"]
+      })) && input3["Base pair-delimited resolutions"].map((elem, _index2) => "number" === typeof elem || $report(_exceptionable2, {
+        path: _path2 + '["Base pair-delimited resolutions"][' + _index2 + "]",
+        expected: "number",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + '["Base pair-delimited resolutions"]',
+        expected: "Array<number>",
+        value: input3["Base pair-delimited resolutions"]
+      }), (Array.isArray(input3["Fragment-delimited resolutions"]) || $report(_exceptionable2, {
+        path: _path2 + '["Fragment-delimited resolutions"]',
+        expected: "Array<number>",
+        value: input3["Fragment-delimited resolutions"]
+      })) && input3["Fragment-delimited resolutions"].map((elem, _index3) => "number" === typeof elem || $report(_exceptionable2, {
+        path: _path2 + '["Fragment-delimited resolutions"][' + _index3 + "]",
+        expected: "number",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + '["Fragment-delimited resolutions"]',
+        expected: "Array<number>",
+        value: input3["Fragment-delimited resolutions"]
+      }), (Array.isArray(input3.normalization) || $report(_exceptionable2, {
+        path: _path2 + ".normalization",
+        expected: "Array<string>",
+        value: input3.normalization
+      })) && input3.normalization.map((elem, _index4) => "string" === typeof elem || $report(_exceptionable2, {
+        path: _path2 + ".normalization[" + _index4 + "]",
+        expected: "string",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".normalization",
+        expected: "Array<string>",
+        value: input3.normalization
+      })].every((flag) => flag);
+      const $vo1 = (input3, _path2, _exceptionable2 = true) => ["number" === typeof input3.All || $report(_exceptionable2, {
+        path: _path2 + ".All",
+        expected: "number",
+        value: input3.All
+      }), "number" === typeof input3.X || $report(_exceptionable2, {
+        path: _path2 + ".X",
+        expected: "number",
+        value: input3.X
+      }), "number" === typeof input3.Y || $report(_exceptionable2, {
+        path: _path2 + ".Y",
+        expected: "number",
+        value: input3.Y
+      }), "number" === typeof input3.M || $report(_exceptionable2, {
+        path: _path2 + ".M",
+        expected: "number",
+        value: input3.M
+      }), false === _exceptionable2 || Object.keys(input3).map((key) => {
+        const value = input3[key];
+        if (void 0 === value)
+          return true;
+        if (RegExp(/^-?\d+\.?\d*$/).test(key))
+          return "number" === typeof value || $report(_exceptionable2, {
+            path: _path2 + $join(key),
+            expected: "number",
+            value
+          });
+        return true;
+      }).every((flag) => flag)].every((flag) => flag);
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: "HicstatResponse",
+        value: input2
+      })) && $vo0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: "HicstatResponse",
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+
+export {
+  hicstatPayload,
+  validHicstatRequest,
+  validHicstatResponse
+};

package/dist/chunk-RLFGMVJZ.js

@@ -0,0 +1,234 @@
+import {
+  __toESM,
+  require_lib
+} from "./chunk-Z6B6IQIY.js";
+
+// dist/burden.ts
+var import_typia = __toESM(require_lib(), 1);
+
+// src/routes/burden.ts
+var burdenPayload = {
+  request: {
+    typeId: "BurdenRequest"
+  },
+  response: {
+    typeId: "BurdenResponse"
+  },
+  examples: [
+    {
+      request: {
+        body: {
+          genome: "hg38",
+          // TODO: !!! use hg38-test and TermdbTest !!!
+          dslabel: "SJLife",
+          diaggrp: 5,
+          sex: 1,
+          white: 1,
+          agedx: 1,
+          bleo: 0,
+          etop: 0,
+          cisp: 0,
+          carbo: 0,
+          steriod: 0,
+          vcr: 0,
+          hdmtx: 0,
+          itmt: 0,
+          ced: 0,
+          dox: 0,
+          heart: 0,
+          brain: 0,
+          abd: 0,
+          pelvis: 0,
+          chest: 0
+        }
+      },
+      response: {
+        header: { status: 200 }
+      }
+    }
+  ]
+};
+
+// dist/burden.ts
+var validBurdenRequest = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    const $io0 = (input3) => "string" === typeof input3.genome && "string" === typeof input3.dslabel && "number" === typeof input3.diaggrp && "number" === typeof input3.sex && "number" === typeof input3.white && "number" === typeof input3.agedx && "number" === typeof input3.bleo && "number" === typeof input3.etop && "number" === typeof input3.cisp && "number" === typeof input3.carbo && "number" === typeof input3.steriod && "number" === typeof input3.vcr && "number" === typeof input3.hdmtx && "number" === typeof input3.itmt && "number" === typeof input3.ced && "number" === typeof input3.dox && "number" === typeof input3.heart && "number" === typeof input3.brain && "number" === typeof input3.abd && "number" === typeof input3.pelvis && "number" === typeof input3.chest;
+    return "object" === typeof input2 && null !== input2 && $io0(input2);
+  };
+  if (false === __is(input)) {
+    const $report = import_typia.createValidate.report(errors);
+    ((input2, _path, _exceptionable = true) => {
+      const $vo0 = (input3, _path2, _exceptionable2 = true) => ["string" === typeof input3.genome || $report(_exceptionable2, {
+        path: _path2 + ".genome",
+        expected: "string",
+        value: input3.genome
+      }), "string" === typeof input3.dslabel || $report(_exceptionable2, {
+        path: _path2 + ".dslabel",
+        expected: "string",
+        value: input3.dslabel
+      }), "number" === typeof input3.diaggrp || $report(_exceptionable2, {
+        path: _path2 + ".diaggrp",
+        expected: "number",
+        value: input3.diaggrp
+      }), "number" === typeof input3.sex || $report(_exceptionable2, {
+        path: _path2 + ".sex",
+        expected: "number",
+        value: input3.sex
+      }), "number" === typeof input3.white || $report(_exceptionable2, {
+        path: _path2 + ".white",
+        expected: "number",
+        value: input3.white
+      }), "number" === typeof input3.agedx || $report(_exceptionable2, {
+        path: _path2 + ".agedx",
+        expected: "number",
+        value: input3.agedx
+      }), "number" === typeof input3.bleo || $report(_exceptionable2, {
+        path: _path2 + ".bleo",
+        expected: "number",
+        value: input3.bleo
+      }), "number" === typeof input3.etop || $report(_exceptionable2, {
+        path: _path2 + ".etop",
+        expected: "number",
+        value: input3.etop
+      }), "number" === typeof input3.cisp || $report(_exceptionable2, {
+        path: _path2 + ".cisp",
+        expected: "number",
+        value: input3.cisp
+      }), "number" === typeof input3.carbo || $report(_exceptionable2, {
+        path: _path2 + ".carbo",
+        expected: "number",
+        value: input3.carbo
+      }), "number" === typeof input3.steriod || $report(_exceptionable2, {
+        path: _path2 + ".steriod",
+        expected: "number",
+        value: input3.steriod
+      }), "number" === typeof input3.vcr || $report(_exceptionable2, {
+        path: _path2 + ".vcr",
+        expected: "number",
+        value: input3.vcr
+      }), "number" === typeof input3.hdmtx || $report(_exceptionable2, {
+        path: _path2 + ".hdmtx",
+        expected: "number",
+        value: input3.hdmtx
+      }), "number" === typeof input3.itmt || $report(_exceptionable2, {
+        path: _path2 + ".itmt",
+        expected: "number",
+        value: input3.itmt
+      }), "number" === typeof input3.ced || $report(_exceptionable2, {
+        path: _path2 + ".ced",
+        expected: "number",
+        value: input3.ced
+      }), "number" === typeof input3.dox || $report(_exceptionable2, {
+        path: _path2 + ".dox",
+        expected: "number",
+        value: input3.dox
+      }), "number" === typeof input3.heart || $report(_exceptionable2, {
+        path: _path2 + ".heart",
+        expected: "number",
+        value: input3.heart
+      }), "number" === typeof input3.brain || $report(_exceptionable2, {
+        path: _path2 + ".brain",
+        expected: "number",
+        value: input3.brain
+      }), "number" === typeof input3.abd || $report(_exceptionable2, {
+        path: _path2 + ".abd",
+        expected: "number",
+        value: input3.abd
+      }), "number" === typeof input3.pelvis || $report(_exceptionable2, {
+        path: _path2 + ".pelvis",
+        expected: "number",
+        value: input3.pelvis
+      }), "number" === typeof input3.chest || $report(_exceptionable2, {
+        path: _path2 + ".chest",
+        expected: "number",
+        value: input3.chest
+      })].every((flag) => flag);
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: "BurdenRequest",
+        value: input2
+      })) && $vo0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: "BurdenRequest",
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+var validBurdenResponse = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    const $io0 = (input3) => "string" === typeof input3.status && (Array.isArray(input3.keys) && input3.keys.every((elem) => "string" === typeof elem)) && (Array.isArray(input3.rows) && input3.rows.every((elem) => Array.isArray(elem) && elem.every((elem2) => "number" === typeof elem2)));
+    return "object" === typeof input2 && null !== input2 && $io0(input2);
+  };
+  if (false === __is(input)) {
+    const $report = import_typia.createValidate.report(errors);
+    ((input2, _path, _exceptionable = true) => {
+      const $vo0 = (input3, _path2, _exceptionable2 = true) => ["string" === typeof input3.status || $report(_exceptionable2, {
+        path: _path2 + ".status",
+        expected: "string",
+        value: input3.status
+      }), (Array.isArray(input3.keys) || $report(_exceptionable2, {
+        path: _path2 + ".keys",
+        expected: "Array<string>",
+        value: input3.keys
+      })) && input3.keys.map((elem, _index1) => "string" === typeof elem || $report(_exceptionable2, {
+        path: _path2 + ".keys[" + _index1 + "]",
+        expected: "string",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".keys",
+        expected: "Array<string>",
+        value: input3.keys
+      }), (Array.isArray(input3.rows) || $report(_exceptionable2, {
+        path: _path2 + ".rows",
+        expected: "Array<Array<number>>",
+        value: input3.rows
+      })) && input3.rows.map((elem, _index2) => (Array.isArray(elem) || $report(_exceptionable2, {
+        path: _path2 + ".rows[" + _index2 + "]",
+        expected: "Array<number>",
+        value: elem
+      })) && elem.map((elem2, _index3) => "number" === typeof elem2 || $report(_exceptionable2, {
+        path: _path2 + ".rows[" + _index2 + "][" + _index3 + "]",
+        expected: "number",
+        value: elem2
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".rows[" + _index2 + "]",
+        expected: "Array<number>",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".rows",
+        expected: "Array<Array<number>>",
+        value: input3.rows
+      })].every((flag) => flag);
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: "BurdenResponse",
+        value: input2
+      })) && $vo0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: "BurdenResponse",
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+
+export {
+  burdenPayload,
+  validBurdenRequest,
+  validBurdenResponse
+};