@sjcrh/proteinpaint-types 2.86.0 → 2.87.1

package/README.md

@@ -10,6 +10,28 @@ Put type definitions that are used in client and server code in this workspace.
 Do NOT put here type definitions that are specific to one workspace,
 those should be saved in the applicable workspace.
 
+## Develop
+
+IMPORTANT: When changing source code that are used to generate runtime 
+checker code, run `npm run generate` after saving changes. This package
+script will call `typia` to generate runtime code from typescript markup. 
+If there are lots of iterations in editing type definitions that could 
+affect run time code generation, you may call `npm run dev` which will
+watch changed `src` files and trigger a call to `typia` to regenerate `dist`
+runtime code.
+
+Consumer code can use type definitions from `@sjcrh/proteinpaint-types`,
+which maps to `src/index.ts`.
+
+Consumer code may also use runtime code from `@sjcrh/proteinpaint-types/checkers`,
+which maps to 
+- `dist/index.js` for server code in nodejs env 
+- `[public_dir]/dist/*.js` for client code in browser environment, requires symlinking
+from `@sjcrh/proteinpaint-types/dist` to somewhere under `public` dir.
+
+Note that in dev environment, `tsx` and `esbuild` are expected to directly transform
+`dist/*.ts` files for server and browser usage, respectively.
+
 ## Test
 
 ```sh

package/dist/brainImaging.js

@@ -0,0 +1,11 @@
+import {
+  brainImagingPayload,
+  validBrainImagingRequest,
+  validBrainImagingResponse
+} from "./chunk-DCN75URO.js";
+import "./chunk-Z6B6IQIY.js";
+export {
+  brainImagingPayload,
+  validBrainImagingRequest,
+  validBrainImagingResponse
+};

package/dist/brainImagingSamples.js

@@ -0,0 +1,11 @@
+import {
+  brainImagingSamplesPayload,
+  validBrainImagingSamplesRequest,
+  validBrainImagingSamplesResponse
+} from "./chunk-OY3EKV7F.js";
+import "./chunk-Z6B6IQIY.js";
+export {
+  brainImagingSamplesPayload,
+  validBrainImagingSamplesRequest,
+  validBrainImagingSamplesResponse
+};

package/dist/burden.js

@@ -0,0 +1,11 @@
+import {
+  burdenPayload,
+  validBurdenRequest,
+  validBurdenResponse
+} from "./chunk-RLFGMVJZ.js";
+import "./chunk-Z6B6IQIY.js";
+export {
+  burdenPayload,
+  validBurdenRequest,
+  validBurdenResponse
+};

package/dist/chunk-37ZPCVP5.js

@@ -0,0 +1,111 @@
+import {
+  __toESM,
+  require_lib
+} from "./chunk-Z6B6IQIY.js";
+
+// dist/termdb.sampleImages.ts
+var import_typia = __toESM(require_lib(), 1);
+
+// src/routes/termdb.sampleImages.ts
+var termdbSampleImagesPayload = {
+  request: {
+    typeId: "TermdbSampleImagesRequest"
+  },
+  response: {
+    typeId: "TermdbSampleImagesResponse"
+  }
+  //examples: []
+};
+
+// dist/termdb.sampleImages.ts
+var validTermdbSampleImagesRequest = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    return "object" === typeof input2 && null !== input2 && ("string" === typeof input2.genome && "string" === typeof input2.dslabel && "number" === typeof input2.sampleId);
+  };
+  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.sampleId || $report(_exceptionable2, {
+        path: _path2 + ".sampleId",
+        expected: "number",
+        value: input3.sampleId
+      })].every((flag) => flag);
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: "TermdbSampleImagesRequest",
+        value: input2
+      })) && $vo0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: "TermdbSampleImagesRequest",
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+var validTermdbSampleImagesResponse = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    const $io0 = (input3) => Array.isArray(input3.images) && input3.images.every((elem) => "object" === typeof elem && null !== elem && $io1(elem));
+    const $io1 = (input3) => 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 $vo0 = (input3, _path2, _exceptionable2 = true) => [(Array.isArray(input3.images) || $report(_exceptionable2, {
+        path: _path2 + ".images",
+        expected: "Array<Image>",
+        value: input3.images
+      })) && input3.images.map((elem, _index1) => ("object" === typeof elem && null !== elem || $report(_exceptionable2, {
+        path: _path2 + ".images[" + _index1 + "]",
+        expected: "Image",
+        value: elem
+      })) && $vo1(elem, _path2 + ".images[" + _index1 + "]", _exceptionable2) || $report(_exceptionable2, {
+        path: _path2 + ".images[" + _index1 + "]",
+        expected: "Image",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".images",
+        expected: "Array<Image>",
+        value: input3.images
+      })].every((flag) => flag);
+      const $vo1 = (input3, _path2, _exceptionable2 = true) => [true].every((flag) => flag);
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: "TermdbSampleImagesResponse",
+        value: input2
+      })) && $vo0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: "TermdbSampleImagesResponse",
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+
+export {
+  termdbSampleImagesPayload,
+  validTermdbSampleImagesRequest,
+  validTermdbSampleImagesResponse
+};

package/dist/chunk-5GG2FNAY.js

@@ -0,0 +1,62 @@
+import {
+  __toESM,
+  require_lib
+} from "./chunk-Z6B6IQIY.js";
+
+// dist/ntseq.ts
+var import_typia = __toESM(require_lib(), 1);
+
+// src/routes/ntseq.ts
+var ntseqPayload = {
+  request: {
+    typeId: "NtseqRequest"
+  },
+  response: {
+    typeId: "NtseqResponse"
+  }
+  //examples: []
+};
+
+// dist/ntseq.ts
+var validNtseqRequest = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    return true;
+  };
+  if (false === __is(input)) {
+    const $report = import_typia.createValidate.report(errors);
+    /* @__PURE__ */ ((input2, _path, _exceptionable = true) => {
+      return true;
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+var validNtseqResponse = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    return true;
+  };
+  if (false === __is(input)) {
+    const $report = import_typia.createValidate.report(errors);
+    /* @__PURE__ */ ((input2, _path, _exceptionable = true) => {
+      return true;
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+
+export {
+  ntseqPayload,
+  validNtseqRequest,
+  validNtseqResponse
+};

package/dist/chunk-5JWTIWVB.js

@@ -0,0 +1,222 @@
+import {
+  __toESM,
+  require_lib
+} from "./chunk-Z6B6IQIY.js";
+
+// dist/hicdata.ts
+var import_typia = __toESM(require_lib(), 1);
+
+// src/routes/hicdata.ts
+var hicdataPayload = {
+  request: {
+    typeId: "HicdataRequest"
+  },
+  response: {
+    typeId: "HicdataResponse"
+  }
+  // examples: []
+};
+
+// dist/hicdata.ts
+var validHicdataRequest = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    const $io0 = (input3) => "string" === typeof input3.file && (null !== input3.url && void 0 === input3.url) && ("observed" === input3.matrixType || "expected" === input3.matrixType || "oe" === input3.matrixType || "log(oe)" === input3.matrixType) && "number" === typeof input3.resolution && "string" === typeof input3.nmeth && "string" === typeof input3.pos1 && "string" === typeof input3.pos2 && (void 0 === input3.isfrag || "boolean" === typeof input3.isfrag) && (void 0 === input3.mincutoff || "number" === typeof input3.mincutoff);
+    const $io1 = (input3) => null !== input3.file && void 0 === input3.file && "string" === typeof input3.url && ("observed" === input3.matrixType || "expected" === input3.matrixType || "oe" === input3.matrixType || "log(oe)" === input3.matrixType) && "number" === typeof input3.resolution && "string" === typeof input3.nmeth && "string" === typeof input3.pos1 && "string" === typeof input3.pos2 && (void 0 === input3.isfrag || "boolean" === typeof input3.isfrag) && (void 0 === input3.mincutoff || "number" === typeof input3.mincutoff);
+    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
+      })), "observed" === input3.matrixType || "expected" === input3.matrixType || "oe" === input3.matrixType || "log(oe)" === input3.matrixType || $report(_exceptionable2, {
+        path: _path2 + ".matrixType",
+        expected: '("expected" | "log(oe)" | "observed" | "oe")',
+        value: input3.matrixType
+      }), "number" === typeof input3.resolution || $report(_exceptionable2, {
+        path: _path2 + ".resolution",
+        expected: "number",
+        value: input3.resolution
+      }), "string" === typeof input3.nmeth || $report(_exceptionable2, {
+        path: _path2 + ".nmeth",
+        expected: "string",
+        value: input3.nmeth
+      }), "string" === typeof input3.pos1 || $report(_exceptionable2, {
+        path: _path2 + ".pos1",
+        expected: "string",
+        value: input3.pos1
+      }), "string" === typeof input3.pos2 || $report(_exceptionable2, {
+        path: _path2 + ".pos2",
+        expected: "string",
+        value: input3.pos2
+      }), void 0 === input3.isfrag || "boolean" === typeof input3.isfrag || $report(_exceptionable2, {
+        path: _path2 + ".isfrag",
+        expected: "(boolean | undefined)",
+        value: input3.isfrag
+      }), void 0 === input3.mincutoff || "number" === typeof input3.mincutoff || $report(_exceptionable2, {
+        path: _path2 + ".mincutoff",
+        expected: "(number | undefined)",
+        value: input3.mincutoff
+      })].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
+      }), "observed" === input3.matrixType || "expected" === input3.matrixType || "oe" === input3.matrixType || "log(oe)" === input3.matrixType || $report(_exceptionable2, {
+        path: _path2 + ".matrixType",
+        expected: '("expected" | "log(oe)" | "observed" | "oe")',
+        value: input3.matrixType
+      }), "number" === typeof input3.resolution || $report(_exceptionable2, {
+        path: _path2 + ".resolution",
+        expected: "number",
+        value: input3.resolution
+      }), "string" === typeof input3.nmeth || $report(_exceptionable2, {
+        path: _path2 + ".nmeth",
+        expected: "string",
+        value: input3.nmeth
+      }), "string" === typeof input3.pos1 || $report(_exceptionable2, {
+        path: _path2 + ".pos1",
+        expected: "string",
+        value: input3.pos1
+      }), "string" === typeof input3.pos2 || $report(_exceptionable2, {
+        path: _path2 + ".pos2",
+        expected: "string",
+        value: input3.pos2
+      }), void 0 === input3.isfrag || "boolean" === typeof input3.isfrag || $report(_exceptionable2, {
+        path: _path2 + ".isfrag",
+        expected: "(boolean | undefined)",
+        value: input3.isfrag
+      }), void 0 === input3.mincutoff || "number" === typeof input3.mincutoff || $report(_exceptionable2, {
+        path: _path2 + ".mincutoff",
+        expected: "(number | undefined)",
+        value: input3.mincutoff
+      })].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: '(URLNotFile & { matrixType: "observed" | "expected" | "oe" | "log(oe)"; resolution: number; nmeth: string; } & { pos1: string; pos2: string; isfrag?: boolean | undefined; mincutoff?: number | undefined; } | FileNotURL & { matrixType: "observed" | "expected" | "oe" | "log(oe)"; resolution: number; nmeth: string; } & { pos1: string; pos2: string; isfrag?: boolean | undefined; mincutoff?: number | undefined; })',
+          value: input3
+        });
+      })();
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: '(FileNotURL & { matrixType: "observed" | "expected" | "oe" | "log(oe)"; resolution: number; nmeth: string; } & { pos1: string; pos2: string; isfrag?: boolean | undefined; mincutoff?: number | undefined; } | URLNotFile & { matrixType: "observed" | "expected" | "oe" | "log(oe)"; resolution: number; nmeth: string; } & { pos1: string; pos2: string; isfrag?: boolean | undefined; mincutoff?: number | undefined; })',
+        value: input2
+      })) && $vu0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: '(FileNotURL & { matrixType: "observed" | "expected" | "oe" | "log(oe)"; resolution: number; nmeth: string; } & { pos1: string; pos2: string; isfrag?: boolean | undefined; mincutoff?: number | undefined; } | URLNotFile & { matrixType: "observed" | "expected" | "oe" | "log(oe)"; resolution: number; nmeth: string; } & { pos1: string; pos2: string; isfrag?: boolean | undefined; mincutoff?: number | undefined; })',
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+var validHicdataResponse = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    const $io0 = (input3) => (void 0 === input3.error || "string" === typeof input3.error) && (Array.isArray(input3.items) && input3.items.every((elem) => Array.isArray(elem) && (elem.length === 3 && "number" === typeof elem[0] && "number" === typeof elem[1] && "number" === typeof elem[2])));
+    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) => [void 0 === input3.error || "string" === typeof input3.error || $report(_exceptionable2, {
+        path: _path2 + ".error",
+        expected: "(string | undefined)",
+        value: input3.error
+      }), (Array.isArray(input3.items) || $report(_exceptionable2, {
+        path: _path2 + ".items",
+        expected: "Array<XYZCoord>",
+        value: input3.items
+      })) && input3.items.map((elem, _index1) => (Array.isArray(elem) || $report(_exceptionable2, {
+        path: _path2 + ".items[" + _index1 + "]",
+        expected: "XYZCoord",
+        value: elem
+      })) && ((elem.length === 3 || $report(_exceptionable2, {
+        path: _path2 + ".items[" + _index1 + "]",
+        expected: "[number, number, number]",
+        value: elem
+      })) && [
+        "number" === typeof elem[0] || $report(_exceptionable2, {
+          path: _path2 + ".items[" + _index1 + "][0]",
+          expected: "number",
+          value: elem[0]
+        }),
+        "number" === typeof elem[1] || $report(_exceptionable2, {
+          path: _path2 + ".items[" + _index1 + "][1]",
+          expected: "number",
+          value: elem[1]
+        }),
+        "number" === typeof elem[2] || $report(_exceptionable2, {
+          path: _path2 + ".items[" + _index1 + "][2]",
+          expected: "number",
+          value: elem[2]
+        })
+      ].every((flag) => flag)) || $report(_exceptionable2, {
+        path: _path2 + ".items[" + _index1 + "]",
+        expected: "XYZCoord",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".items",
+        expected: "Array<XYZCoord>",
+        value: input3.items
+      })].every((flag) => flag);
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: "HicdataResponse",
+        value: input2
+      })) && $vo0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: "HicdataResponse",
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+
+export {
+  hicdataPayload,
+  validHicdataRequest,
+  validHicdataResponse
+};

package/dist/chunk-5RZYB4M4.js

@@ -0,0 +1,171 @@
+import {
+  __toESM,
+  require_lib
+} from "./chunk-Z6B6IQIY.js";
+
+// dist/termdb.termchildren.ts
+var import_typia = __toESM(require_lib(), 1);
+
+// src/routes/termdb.termchildren.ts
+var termChildrenPayload = {
+  request: {
+    typeId: "TermChildrenRequest"
+  },
+  response: {
+    typeId: "TermChildrenResponse"
+  },
+  examples: [
+    {
+      request: {
+        body: {
+          genome: "hg38-test",
+          dslabel: "TermdbTest",
+          embedder: "localhost",
+          get_children: 1,
+          cohortValues: "ABC",
+          tid: "GO:0000001"
+        }
+      },
+      response: {
+        header: { status: 200 }
+      }
+    }
+  ]
+};
+
+// dist/termdb.termchildren.ts
+var validTermChildrenRequest = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    return "object" === typeof input2 && null !== input2 && ("string" === typeof input2.genome && "string" === typeof input2.dslabel && "string" === typeof input2.embedder && "number" === typeof input2.get_children && "string" === typeof input2.tid);
+  };
+  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.embedder || $report(_exceptionable2, {
+        path: _path2 + ".embedder",
+        expected: "string",
+        value: input3.embedder
+      }), "number" === typeof input3.get_children || $report(_exceptionable2, {
+        path: _path2 + ".get_children",
+        expected: "number",
+        value: input3.get_children
+      }), "string" === typeof input3.tid || $report(_exceptionable2, {
+        path: _path2 + ".tid",
+        expected: "string",
+        value: input3.tid
+      })].every((flag) => flag);
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: "TermChildrenRequest",
+        value: input2
+      })) && $vo0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: "TermChildrenRequest",
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+var validTermChildrenResponse = (input) => {
+  const errors = [];
+  const __is = (input2) => {
+    const $io0 = (input3) => Array.isArray(input3.lst) && input3.lst.every((elem) => "object" === typeof elem && null !== elem && $io1(elem));
+    const $io1 = (input3) => "string" === typeof input3.name && "string" === typeof input3.id && "boolean" === typeof input3.isleaf && (Array.isArray(input3.included_types) && input3.included_types.every((elem) => "string" === typeof elem)) && (Array.isArray(input3.child_types) && input3.child_types.every((elem) => "string" === typeof elem));
+    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) => [(Array.isArray(input3.lst) || $report(_exceptionable2, {
+        path: _path2 + ".lst",
+        expected: "Array<Entries>",
+        value: input3.lst
+      })) && input3.lst.map((elem, _index1) => ("object" === typeof elem && null !== elem || $report(_exceptionable2, {
+        path: _path2 + ".lst[" + _index1 + "]",
+        expected: "Entries",
+        value: elem
+      })) && $vo1(elem, _path2 + ".lst[" + _index1 + "]", _exceptionable2) || $report(_exceptionable2, {
+        path: _path2 + ".lst[" + _index1 + "]",
+        expected: "Entries",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".lst",
+        expected: "Array<Entries>",
+        value: input3.lst
+      })].every((flag) => flag);
+      const $vo1 = (input3, _path2, _exceptionable2 = true) => ["string" === typeof input3.name || $report(_exceptionable2, {
+        path: _path2 + ".name",
+        expected: "string",
+        value: input3.name
+      }), "string" === typeof input3.id || $report(_exceptionable2, {
+        path: _path2 + ".id",
+        expected: "string",
+        value: input3.id
+      }), "boolean" === typeof input3.isleaf || $report(_exceptionable2, {
+        path: _path2 + ".isleaf",
+        expected: "boolean",
+        value: input3.isleaf
+      }), (Array.isArray(input3.included_types) || $report(_exceptionable2, {
+        path: _path2 + ".included_types",
+        expected: "Array<string>",
+        value: input3.included_types
+      })) && input3.included_types.map((elem, _index2) => "string" === typeof elem || $report(_exceptionable2, {
+        path: _path2 + ".included_types[" + _index2 + "]",
+        expected: "string",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".included_types",
+        expected: "Array<string>",
+        value: input3.included_types
+      }), (Array.isArray(input3.child_types) || $report(_exceptionable2, {
+        path: _path2 + ".child_types",
+        expected: "Array<string>",
+        value: input3.child_types
+      })) && input3.child_types.map((elem, _index3) => "string" === typeof elem || $report(_exceptionable2, {
+        path: _path2 + ".child_types[" + _index3 + "]",
+        expected: "string",
+        value: elem
+      })).every((flag) => flag) || $report(_exceptionable2, {
+        path: _path2 + ".child_types",
+        expected: "Array<string>",
+        value: input3.child_types
+      })].every((flag) => flag);
+      return ("object" === typeof input2 && null !== input2 || $report(true, {
+        path: _path + "",
+        expected: "TermChildrenResponse",
+        value: input2
+      })) && $vo0(input2, _path + "", true) || $report(true, {
+        path: _path + "",
+        expected: "TermChildrenResponse",
+        value: input2
+      });
+    })(input, "$input", true);
+  }
+  const success = 0 === errors.length;
+  return {
+    success,
+    errors,
+    data: success ? input : void 0
+  };
+};
+
+export {
+  termChildrenPayload,
+  validTermChildrenRequest,
+  validTermChildrenResponse
+};