@prosopo/types 2.1.8 → 2.1.9

package/dist/datasets/captcha.js

@@ -0,0 +1,101 @@
+import { array, custom, nativeEnum, number, object, string, union, number as zNumber, undefined as zUndefined, } from "zod";
+export var CaptchaTypes;
+(function (CaptchaTypes) {
+    CaptchaTypes["SelectAll"] = "SelectAll";
+})(CaptchaTypes || (CaptchaTypes = {}));
+export var CaptchaItemTypes;
+(function (CaptchaItemTypes) {
+    CaptchaItemTypes["Text"] = "text";
+    CaptchaItemTypes["Image"] = "image";
+})(CaptchaItemTypes || (CaptchaItemTypes = {}));
+export var CaptchaStates;
+(function (CaptchaStates) {
+    CaptchaStates["Solved"] = "solved";
+    CaptchaStates["Unsolved"] = "unsolved";
+})(CaptchaStates || (CaptchaStates = {}));
+export var CaptchaStatus;
+(function (CaptchaStatus) {
+    CaptchaStatus["pending"] = "Pending";
+    CaptchaStatus["approved"] = "Approved";
+    CaptchaStatus["disapproved"] = "Disapproved";
+})(CaptchaStatus || (CaptchaStatus = {}));
+export var GovernanceStatus;
+(function (GovernanceStatus) {
+    GovernanceStatus["active"] = "Active";
+    GovernanceStatus["inactive"] = "Inactive";
+})(GovernanceStatus || (GovernanceStatus = {}));
+export var DappPayee;
+(function (DappPayee) {
+    DappPayee["provider"] = "Provider";
+    DappPayee["dapp"] = "Dapp";
+    DappPayee["any"] = "Any";
+})(DappPayee || (DappPayee = {}));
+export const TimestampSchema = zNumber();
+export const POW_SEPARATOR = "___";
+export const PowChallengeIdSchema = custom((val) => {
+    const valSplit = val.split(POW_SEPARATOR);
+    try {
+        Number.parseInt(valSplit[0]);
+        return valSplit.length === 3;
+    }
+    catch (e) {
+        return false;
+    }
+});
+export const CaptchaSchema = object({
+    captchaId: union([string(), zUndefined()]),
+    captchaContentId: union([string(), zUndefined()]),
+    salt: string().min(34),
+    solution: number().array().optional(),
+    unlabelled: number().array().optional(),
+    timeLimit: number().optional(),
+});
+export const CaptchaItemSchema = object({
+    hash: string(),
+    data: string(),
+    type: nativeEnum(CaptchaItemTypes),
+});
+export const HashedCaptchaItemSchema = CaptchaItemSchema.extend({
+    hash: string(),
+});
+export const LabelledItemSchema = HashedCaptchaItemSchema.extend({
+    label: string(),
+});
+export const MaybeLabelledHashedItemSchema = HashedCaptchaItemSchema.extend({
+    label: string().optional(),
+});
+export const SelectAllCaptchaSchemaRaw = CaptchaSchema.extend({
+    items: array(CaptchaItemSchema),
+    target: string(),
+});
+export const SelectAllCaptchaSchema = SelectAllCaptchaSchemaRaw.extend({
+    solution: string().array().optional(),
+    unlabelled: string().array().optional(),
+});
+export const SelectAllCaptchaSchemaWithNumericSolution = SelectAllCaptchaSchema.extend({
+    solution: number().array().optional(),
+    unlabelled: number().array().optional(),
+});
+export const CaptchasSchema = array(SelectAllCaptchaSchemaRaw);
+export const CaptchasWithNumericSolutionSchema = array(SelectAllCaptchaSchemaWithNumericSolution);
+export const CaptchaSolutionSchema = object({
+    captchaId: string(),
+    captchaContentId: string(),
+    solution: string().array(),
+    salt: string().min(34),
+});
+export const CaptchaSolutionArraySchema = array(CaptchaSolutionSchema);
+export const DataSchema = object({
+    items: array(MaybeLabelledHashedItemSchema),
+});
+export const LabelledDataSchema = object({
+    items: array(LabelledItemSchema),
+});
+export const CaptchasContainerSchema = object({
+    captchas: CaptchasSchema,
+    format: nativeEnum(CaptchaTypes),
+});
+export const LabelsContainerSchema = object({
+    labels: array(string()),
+});
+//# sourceMappingURL=captcha.js.map

package/dist/datasets/captcha.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"captcha.js","sourceRoot":"","sources":["../../src/datasets/captcha.ts"],"names":[],"mappings":"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"}

package/dist/datasets/dataset.d.ts

@@ -0,0 +1,482 @@
+import type { Hash } from "@prosopo/types";
+import { type Captcha, CaptchaTypes, type CaptchaWithoutId } from "./captcha.js";
+export type DatasetBase = {
+    datasetId?: Hash;
+    datasetContentId?: Hash;
+    format: CaptchaTypes;
+    contentTree?: string[][];
+    solutionTree?: string[][];
+};
+export interface Dataset extends DatasetBase {
+    captchas: CaptchaWithoutId[] | Captcha[];
+}
+export interface DatasetRaw extends DatasetBase {
+    captchas: CaptchaWithoutId[];
+}
+export type DatasetWithIds = {
+    datasetId: Hash;
+    datasetContentId: Hash;
+    captchas: Captcha[];
+    format: CaptchaTypes;
+    contentTree?: string[][];
+    solutionTree?: string[][];
+};
+export interface DatasetWithIdsAndTree extends DatasetWithIds {
+    contentTree: string[][];
+}
+export declare const DatasetSchema: import("zod").ZodObject<{
+    datasetId: import("zod").ZodOptional<import("zod").ZodString>;
+    datasetContentId: import("zod").ZodOptional<import("zod").ZodString>;
+    captchas: import("zod").ZodArray<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+        captchaId: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodUndefined]>;
+        captchaContentId: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodUndefined]>;
+        salt: import("zod").ZodString;
+        solution: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        unlabelled: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        timeLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, {
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            hash: import("zod").ZodString;
+            data: import("zod").ZodString;
+            type: import("zod").ZodNativeEnum<typeof import("@prosopo/types").CaptchaItemTypes>;
+        }, "strip", import("zod").ZodTypeAny, {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }, {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }>, "many">;
+        target: import("zod").ZodString;
+    }>, "strip", import("zod").ZodTypeAny, {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        unlabelled?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }, {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        unlabelled?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }>, "many">;
+    format: import("zod").ZodNativeEnum<typeof CaptchaTypes>;
+    solutionTree: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString, "many">, "many">>;
+    contentTree: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString, "many">, "many">>;
+    timeLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, "strip", import("zod").ZodTypeAny, {
+    captchas: {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        unlabelled?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }[];
+    format: CaptchaTypes;
+    timeLimit?: number | undefined;
+    datasetId?: string | undefined;
+    datasetContentId?: string | undefined;
+    solutionTree?: string[][] | undefined;
+    contentTree?: string[][] | undefined;
+}, {
+    captchas: {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        unlabelled?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }[];
+    format: CaptchaTypes;
+    timeLimit?: number | undefined;
+    datasetId?: string | undefined;
+    datasetContentId?: string | undefined;
+    solutionTree?: string[][] | undefined;
+    contentTree?: string[][] | undefined;
+}>;
+export declare const DatasetWithNumericSolutionSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    datasetId: import("zod").ZodOptional<import("zod").ZodString>;
+    datasetContentId: import("zod").ZodOptional<import("zod").ZodString>;
+    captchas: import("zod").ZodArray<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+        captchaId: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodUndefined]>;
+        captchaContentId: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodUndefined]>;
+        salt: import("zod").ZodString;
+        solution: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        unlabelled: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        timeLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, {
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            hash: import("zod").ZodString;
+            data: import("zod").ZodString;
+            type: import("zod").ZodNativeEnum<typeof import("@prosopo/types").CaptchaItemTypes>;
+        }, "strip", import("zod").ZodTypeAny, {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }, {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }>, "many">;
+        target: import("zod").ZodString;
+    }>, "strip", import("zod").ZodTypeAny, {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        unlabelled?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }, {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        unlabelled?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }>, "many">;
+    format: import("zod").ZodNativeEnum<typeof CaptchaTypes>;
+    solutionTree: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString, "many">, "many">>;
+    contentTree: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString, "many">, "many">>;
+    timeLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, {
+    captchas: import("zod").ZodArray<import("zod").ZodObject<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<{
+        captchaId: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodUndefined]>;
+        captchaContentId: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodUndefined]>;
+        salt: import("zod").ZodString;
+        solution: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        unlabelled: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        timeLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, {
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            hash: import("zod").ZodString;
+            data: import("zod").ZodString;
+            type: import("zod").ZodNativeEnum<typeof import("@prosopo/types").CaptchaItemTypes>;
+        }, "strip", import("zod").ZodTypeAny, {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }, {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }>, "many">;
+        target: import("zod").ZodString;
+    }>, {
+        solution: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        unlabelled: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    }>, {
+        solution: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        unlabelled: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+    }>, "strip", import("zod").ZodTypeAny, {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        unlabelled?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }, {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        unlabelled?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }>, "many">;
+}>, "strip", import("zod").ZodTypeAny, {
+    captchas: {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        unlabelled?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }[];
+    format: CaptchaTypes;
+    timeLimit?: number | undefined;
+    datasetId?: string | undefined;
+    datasetContentId?: string | undefined;
+    solutionTree?: string[][] | undefined;
+    contentTree?: string[][] | undefined;
+}, {
+    captchas: {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        unlabelled?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }[];
+    format: CaptchaTypes;
+    timeLimit?: number | undefined;
+    datasetId?: string | undefined;
+    datasetContentId?: string | undefined;
+    solutionTree?: string[][] | undefined;
+    contentTree?: string[][] | undefined;
+}>;
+export declare const DatasetWithIdsSchema: import("zod").ZodObject<{
+    datasetId: import("zod").ZodString;
+    datasetContentId: import("zod").ZodOptional<import("zod").ZodString>;
+    captchas: import("zod").ZodArray<import("zod").ZodObject<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<{
+        captchaId: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodUndefined]>;
+        captchaContentId: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodUndefined]>;
+        salt: import("zod").ZodString;
+        solution: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        unlabelled: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        timeLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, {
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            hash: import("zod").ZodString;
+            data: import("zod").ZodString;
+            type: import("zod").ZodNativeEnum<typeof import("@prosopo/types").CaptchaItemTypes>;
+        }, "strip", import("zod").ZodTypeAny, {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }, {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }>, "many">;
+        target: import("zod").ZodString;
+    }>, {
+        solution: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        unlabelled: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    }>, "strip", import("zod").ZodTypeAny, {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: string[] | undefined;
+        unlabelled?: string[] | undefined;
+        timeLimit?: number | undefined;
+    }, {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: string[] | undefined;
+        unlabelled?: string[] | undefined;
+        timeLimit?: number | undefined;
+    }>, "many">;
+    format: import("zod").ZodNativeEnum<typeof CaptchaTypes>;
+    solutionTree: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString, "many">, "many">>;
+    contentTree: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString, "many">, "many">>;
+}, "strip", import("zod").ZodTypeAny, {
+    captchas: {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: string[] | undefined;
+        unlabelled?: string[] | undefined;
+        timeLimit?: number | undefined;
+    }[];
+    format: CaptchaTypes;
+    datasetId: string;
+    datasetContentId?: string | undefined;
+    solutionTree?: string[][] | undefined;
+    contentTree?: string[][] | undefined;
+}, {
+    captchas: {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: string[] | undefined;
+        unlabelled?: string[] | undefined;
+        timeLimit?: number | undefined;
+    }[];
+    format: CaptchaTypes;
+    datasetId: string;
+    datasetContentId?: string | undefined;
+    solutionTree?: string[][] | undefined;
+    contentTree?: string[][] | undefined;
+}>;
+export declare const DatasetWithIdsAndTreeSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    datasetId: import("zod").ZodString;
+    datasetContentId: import("zod").ZodOptional<import("zod").ZodString>;
+    captchas: import("zod").ZodArray<import("zod").ZodObject<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<{
+        captchaId: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodUndefined]>;
+        captchaContentId: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodUndefined]>;
+        salt: import("zod").ZodString;
+        solution: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        unlabelled: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        timeLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, {
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            hash: import("zod").ZodString;
+            data: import("zod").ZodString;
+            type: import("zod").ZodNativeEnum<typeof import("@prosopo/types").CaptchaItemTypes>;
+        }, "strip", import("zod").ZodTypeAny, {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }, {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }>, "many">;
+        target: import("zod").ZodString;
+    }>, {
+        solution: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        unlabelled: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    }>, "strip", import("zod").ZodTypeAny, {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: string[] | undefined;
+        unlabelled?: string[] | undefined;
+        timeLimit?: number | undefined;
+    }, {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: string[] | undefined;
+        unlabelled?: string[] | undefined;
+        timeLimit?: number | undefined;
+    }>, "many">;
+    format: import("zod").ZodNativeEnum<typeof CaptchaTypes>;
+    solutionTree: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString, "many">, "many">>;
+    contentTree: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString, "many">, "many">>;
+}, {
+    solutionTree: import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString, "many">, "many">;
+    contentTree: import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString, "many">, "many">;
+}>, "strip", import("zod").ZodTypeAny, {
+    captchas: {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: string[] | undefined;
+        unlabelled?: string[] | undefined;
+        timeLimit?: number | undefined;
+    }[];
+    format: CaptchaTypes;
+    datasetId: string;
+    solutionTree: string[][];
+    contentTree: string[][];
+    datasetContentId?: string | undefined;
+}, {
+    captchas: {
+        items: {
+            hash: string;
+            data: string;
+            type: import("@prosopo/types").CaptchaItemTypes;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: string[] | undefined;
+        unlabelled?: string[] | undefined;
+        timeLimit?: number | undefined;
+    }[];
+    format: CaptchaTypes;
+    datasetId: string;
+    solutionTree: string[][];
+    contentTree: string[][];
+    datasetContentId?: string | undefined;
+}>;
+//# sourceMappingURL=dataset.d.ts.map

package/dist/datasets/dataset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset.d.ts","sourceRoot":"","sources":["../../src/datasets/dataset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAe3C,OAAO,EACN,KAAK,OAAO,EACZ,YAAY,EACZ,KAAK,gBAAgB,EAIrB,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,WAAW,GAAG;IACzB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,gBAAgB,CAAC,EAAE,IAAI,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,WAAW,OAAQ,SAAQ,WAAW;IAC3C,QAAQ,EAAE,gBAAgB,EAAE,GAAG,OAAO,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,UAAW,SAAQ,WAAW;IAC9C,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAED,MAAM,MAAM,cAAc,GAAG;IAC5B,SAAS,EAAE,IAAI,CAAC;IAChB,gBAAgB,EAAE,IAAI,CAAC;IACvB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,MAAM,EAAE,YAAY,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IAC5D,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;CACxB;AAID,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQxB,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3C,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO/B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAC"}

package/dist/datasets/dataset.js

@@ -0,0 +1,27 @@
+import { array, nativeEnum, number, object, string } from "zod";
+import { CaptchaTypes, CaptchasSchema, CaptchasWithNumericSolutionSchema, SelectAllCaptchaSchema, } from "./captcha.js";
+export const DatasetSchema = object({
+    datasetId: string().optional(),
+    datasetContentId: string().optional(),
+    captchas: CaptchasSchema,
+    format: nativeEnum(CaptchaTypes),
+    solutionTree: array(array(string())).optional(),
+    contentTree: array(array(string())).optional(),
+    timeLimit: number().optional(),
+});
+export const DatasetWithNumericSolutionSchema = DatasetSchema.extend({
+    captchas: CaptchasWithNumericSolutionSchema,
+});
+export const DatasetWithIdsSchema = object({
+    datasetId: string(),
+    datasetContentId: string().optional(),
+    captchas: array(SelectAllCaptchaSchema),
+    format: nativeEnum(CaptchaTypes),
+    solutionTree: array(array(string())).optional(),
+    contentTree: array(array(string())).optional(),
+});
+export const DatasetWithIdsAndTreeSchema = DatasetWithIdsSchema.extend({
+    solutionTree: array(array(string())),
+    contentTree: array(array(string())),
+});
+//# sourceMappingURL=dataset.js.map

package/dist/datasets/dataset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset.js","sourceRoot":"","sources":["../../src/datasets/dataset.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC;AAchE,OAAO,EAEN,YAAY,EAEZ,cAAc,EACd,iCAAiC,EACjC,sBAAsB,GACtB,MAAM,cAAc,CAAC;AAiCtB,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC;IACnC,SAAS,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,gBAAgB,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC,QAAQ,EAAE,cAAc;IACxB,MAAM,EAAE,UAAU,CAAC,YAAY,CAAC;IAChC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC/C,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC9C,SAAS,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC9B,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,gCAAgC,GAAG,aAAa,CAAC,MAAM,CAAC;IACpE,QAAQ,EAAE,iCAAiC;CAC3C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC;IAC1C,SAAS,EAAE,MAAM,EAAE;IACnB,gBAAgB,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC,QAAQ,EAAE,KAAK,CAAC,sBAAsB,CAAC;IACvC,MAAM,EAAE,UAAU,CAAC,YAAY,CAAC;IAChC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC/C,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;CAC9C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,2BAA2B,GAAG,oBAAoB,CAAC,MAAM,CAAC;IACtE,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IACpC,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;CACnC,CAAC,CAAC"}

package/dist/datasets/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./captcha.js";
+export * from "./dataset.js";
+export * from "./merkle.js";
+export * from "./assets.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/datasets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/datasets/index.ts"],"names":[],"mappings":"AAaA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

package/dist/datasets/index.js

@@ -0,0 +1,5 @@
+export * from "./captcha.js";
+export * from "./dataset.js";
+export * from "./merkle.js";
+export * from "./assets.js";
+//# sourceMappingURL=index.js.map

package/dist/datasets/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/datasets/index.ts"],"names":[],"mappings":"AAaA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

package/dist/datasets/merkle.d.ts

@@ -0,0 +1,10 @@
+export interface MerkleNodeInterface {
+    hash: string;
+    parent: string | null;
+}
+export type MerkleLeaf = string;
+export type MerkleLayer = MerkleLeaf[];
+export type MerkleProofLayer = [MerkleLeaf, MerkleLeaf];
+export type MerkleRootLayer = [MerkleLeaf];
+export type MerkleProof = [...MerkleProofLayer[], MerkleRootLayer];
+//# sourceMappingURL=merkle.d.ts.map

package/dist/datasets/merkle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle.d.ts","sourceRoot":"","sources":["../../src/datasets/merkle.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,mBAAmB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC,MAAM,MAAM,WAAW,GAAG,UAAU,EAAE,CAAC;AAEvC,MAAM,MAAM,gBAAgB,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AAExD,MAAM,MAAM,eAAe,GAAG,CAAC,UAAU,CAAC,CAAC;AAE3C,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,gBAAgB,EAAE,EAAE,eAAe,CAAC,CAAC"}

package/dist/datasets/merkle.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=merkle.js.map