@prosopo/datasets-fs 3.0.152 → 3.0.154

package/dist/types/commands/generateV2.d.ts

@@ -0,0 +1,189 @@
+import * as z from "zod";
+import { Generate } from "./generate.js";
+export declare const ArgsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    output: z.ZodString;
+    overwrite: z.ZodOptional<z.ZodBoolean>;
+}, {
+    labels: z.ZodOptional<z.ZodString>;
+    labelled: z.ZodOptional<z.ZodString>;
+    unlabelled: z.ZodOptional<z.ZodString>;
+    seed: z.ZodNumber;
+    size: z.ZodOptional<z.ZodNumber>;
+    overwrite: z.ZodOptional<z.ZodBoolean>;
+    allowDuplicates: z.ZodOptional<z.ZodBoolean>;
+    allowDuplicatesLabelled: z.ZodOptional<z.ZodBoolean>;
+    allowDuplicatesUnlabelled: z.ZodOptional<z.ZodBoolean>;
+}>, {
+    minCorrect: z.ZodOptional<z.ZodNumber>;
+    minIncorrect: z.ZodOptional<z.ZodNumber>;
+    minLabelled: z.ZodOptional<z.ZodNumber>;
+    maxLabelled: z.ZodOptional<z.ZodNumber>;
+    count: z.ZodOptional<z.ZodNumber>;
+}>, "strip", z.ZodTypeAny, {
+    output: string;
+    seed: number;
+    overwrite?: boolean | undefined;
+    allowDuplicates?: boolean | undefined;
+    labels?: string | undefined;
+    labelled?: string | undefined;
+    unlabelled?: string | undefined;
+    size?: number | undefined;
+    allowDuplicatesLabelled?: boolean | undefined;
+    allowDuplicatesUnlabelled?: boolean | undefined;
+    minCorrect?: number | undefined;
+    minIncorrect?: number | undefined;
+    minLabelled?: number | undefined;
+    maxLabelled?: number | undefined;
+    count?: number | undefined;
+}, {
+    output: string;
+    seed: number;
+    overwrite?: boolean | undefined;
+    allowDuplicates?: boolean | undefined;
+    labels?: string | undefined;
+    labelled?: string | undefined;
+    unlabelled?: string | undefined;
+    size?: number | undefined;
+    allowDuplicatesLabelled?: boolean | undefined;
+    allowDuplicatesUnlabelled?: boolean | undefined;
+    minCorrect?: number | undefined;
+    minIncorrect?: number | undefined;
+    minLabelled?: number | undefined;
+    maxLabelled?: number | undefined;
+    count?: number | undefined;
+}>;
+export type ArgsSchemaType = typeof ArgsSchema;
+export type Args = z.infer<ArgsSchemaType>;
+export declare class GenerateV2 extends Generate<ArgsSchemaType> {
+    #private;
+    getArgSchema(): z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+        output: z.ZodString;
+        overwrite: z.ZodOptional<z.ZodBoolean>;
+    }, {
+        labels: z.ZodOptional<z.ZodString>;
+        labelled: z.ZodOptional<z.ZodString>;
+        unlabelled: z.ZodOptional<z.ZodString>;
+        seed: z.ZodNumber;
+        size: z.ZodOptional<z.ZodNumber>;
+        overwrite: z.ZodOptional<z.ZodBoolean>;
+        allowDuplicates: z.ZodOptional<z.ZodBoolean>;
+        allowDuplicatesLabelled: z.ZodOptional<z.ZodBoolean>;
+        allowDuplicatesUnlabelled: z.ZodOptional<z.ZodBoolean>;
+    }>, {
+        minCorrect: z.ZodOptional<z.ZodNumber>;
+        minIncorrect: z.ZodOptional<z.ZodNumber>;
+        minLabelled: z.ZodOptional<z.ZodNumber>;
+        maxLabelled: z.ZodOptional<z.ZodNumber>;
+        count: z.ZodOptional<z.ZodNumber>;
+    }>, "strip", z.ZodTypeAny, {
+        output: string;
+        seed: number;
+        overwrite?: boolean | undefined;
+        allowDuplicates?: boolean | undefined;
+        labels?: string | undefined;
+        labelled?: string | undefined;
+        unlabelled?: string | undefined;
+        size?: number | undefined;
+        allowDuplicatesLabelled?: boolean | undefined;
+        allowDuplicatesUnlabelled?: boolean | undefined;
+        minCorrect?: number | undefined;
+        minIncorrect?: number | undefined;
+        minLabelled?: number | undefined;
+        maxLabelled?: number | undefined;
+        count?: number | undefined;
+    }, {
+        output: string;
+        seed: number;
+        overwrite?: boolean | undefined;
+        allowDuplicates?: boolean | undefined;
+        labels?: string | undefined;
+        labelled?: string | undefined;
+        unlabelled?: string | undefined;
+        size?: number | undefined;
+        allowDuplicatesLabelled?: boolean | undefined;
+        allowDuplicatesUnlabelled?: boolean | undefined;
+        minCorrect?: number | undefined;
+        minIncorrect?: number | undefined;
+        minLabelled?: number | undefined;
+        maxLabelled?: number | undefined;
+        count?: number | undefined;
+    }>;
+    getDescription(): string;
+    getOptions(): {
+        [key: string]: import("yargs").Options;
+    } & {
+        output: {
+            alias: string;
+            string: boolean;
+            demand: boolean;
+            description: string;
+        };
+        overwrite: {
+            boolean: boolean;
+            description: string;
+        };
+    } & {
+        output: {
+            description: string;
+        };
+        labelled: {
+            string: boolean;
+            demand: boolean;
+            description: string;
+        };
+        unlabelled: {
+            string: boolean;
+            demand: boolean;
+            description: string;
+        };
+        seed: {
+            number: boolean;
+            demand: boolean;
+            description: string;
+        };
+        size: {
+            number: boolean;
+            description: string;
+        };
+        labels: {
+            string: boolean;
+            description: string;
+        };
+        allowDuplicates: {
+            boolean: boolean;
+            description: string;
+        };
+        allowDuplicatesLabelled: {
+            boolean: boolean;
+            description: string;
+        };
+        allowDuplicatesUnlabelled: {
+            boolean: boolean;
+            description: string;
+        };
+    } & {
+        count: {
+            number: boolean;
+            description: string;
+        };
+        minCorrect: {
+            number: boolean;
+            description: string;
+        };
+        minIncorrect: {
+            number: boolean;
+            description: string;
+        };
+        minLabelled: {
+            number: boolean;
+            description: string;
+        };
+        maxLabelled: {
+            number: boolean;
+            description: string;
+        };
+    };
+    private setupTarget;
+    _run(args: Args): Promise<void>;
+}
+//# sourceMappingURL=generateV2.d.ts.map

package/dist/types/commands/generateV2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateV2.d.ts","sourceRoot":"","sources":["../../../src/commands/generateV2.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAE,QAAQ,EAAoC,MAAM,eAAe,CAAC;AAE3E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMrB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,UAAU,CAAC;AAC/C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;AAE3C,qBAAa,UAAW,SAAQ,QAAQ,CAAC,cAAc,CAAC;;IAmBvC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIZ,cAAc,IAAI,MAAM;IAIxB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAyB1B,OAAO,CAAC,WAAW;IA4DG,IAAI,CAAC,IAAI,EAAE,IAAI;CAyIrC"}

package/dist/types/commands/get.d.ts

@@ -0,0 +1,35 @@
+import * as z from "zod";
+import { InputCliCommand } from "../utils/input.js";
+export declare const ArgsSchema: z.ZodObject<z.objectUtil.extendShape<{
+    input: z.ZodString;
+}, {}>, "strip", z.ZodTypeAny, {
+    input: string;
+}, {
+    input: string;
+}>;
+export type ArgsSchemaType = typeof ArgsSchema;
+export type Args = z.infer<ArgsSchemaType>;
+export declare class Get extends InputCliCommand<ArgsSchemaType> {
+    getArgSchema(): z.ZodObject<z.objectUtil.extendShape<{
+        input: z.ZodString;
+    }, {}>, "strip", z.ZodTypeAny, {
+        input: string;
+    }, {
+        input: string;
+    }>;
+    getOptions(): {
+        input: {
+            string: boolean;
+            alias: string;
+            demand: boolean;
+            description: string;
+        };
+    } & {
+        input: {
+            description: string;
+        };
+    };
+    _run(args: Args): Promise<void>;
+    getDescription(): string;
+}
+//# sourceMappingURL=get.d.ts.map

package/dist/types/commands/get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../src/commands/get.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAmB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAErE,eAAO,MAAM,UAAU;;;;;;EAA6B,CAAC;AACrD,MAAM,MAAM,cAAc,GAAG,OAAO,UAAU,CAAC;AAC/C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;AAC3C,qBAAa,GAAI,SAAQ,eAAe,CAAC,cAAc,CAAC;IACvC,YAAY;;;;;;;IAIZ,UAAU;;;;;;;;;;;;IAQJ,IAAI,CAAC,IAAI,EAAE,IAAI;IAyErB,cAAc,IAAI,MAAM;CAGxC"}

package/dist/types/commands/labels.d.ts

@@ -0,0 +1,47 @@
+import type * as z from "zod";
+import { InputOutputCliCommand } from "../utils/inputOutput.js";
+export declare const ArgsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    input: z.ZodString;
+}, {
+    output: z.ZodString;
+    overwrite: z.ZodOptional<z.ZodBoolean>;
+}>, {}>, "strip", z.ZodTypeAny, {
+    input: string;
+    output: string;
+    overwrite?: boolean | undefined;
+}, {
+    input: string;
+    output: string;
+    overwrite?: boolean | undefined;
+}>;
+export type ArgsSchemaType = typeof ArgsSchema;
+export type Args = z.infer<ArgsSchemaType>;
+export declare class Labels extends InputOutputCliCommand<ArgsSchemaType> {
+    getArgSchema(): z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+        input: z.ZodString;
+    }, {
+        output: z.ZodString;
+        overwrite: z.ZodOptional<z.ZodBoolean>;
+    }>, {}>, "strip", z.ZodTypeAny, {
+        input: string;
+        output: string;
+        overwrite?: boolean | undefined;
+    }, {
+        input: string;
+        output: string;
+        overwrite?: boolean | undefined;
+    }>;
+    getOptions(): {
+        [key: string]: import("yargs").Options;
+    } & {
+        input: {
+            description: string;
+        };
+        output: {
+            description: string;
+        };
+    };
+    _run(args: Args): Promise<void>;
+    getDescription(): string;
+}
+//# sourceMappingURL=labels.d.ts.map

package/dist/types/commands/labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../../src/commands/labels.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAC;AAC9B,OAAO,EAEN,qBAAqB,EACrB,MAAM,yBAAyB,CAAC;AAEjC,eAAO,MAAM,UAAU;;;;;;;;;;;;;EAAmC,CAAC;AAC3D,MAAM,MAAM,cAAc,GAAG,OAAO,UAAU,CAAC;AAC/C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;AAE3C,qBAAa,MAAO,SAAQ,qBAAqB,CAAC,cAAc,CAAC;IAChD,YAAY;;;;;;;;;;;;;;IAIZ,UAAU;;;;;;;;;;IAWJ,IAAI,CAAC,IAAI,EAAE,IAAI;IAiCrB,cAAc,IAAI,MAAM;CAGxC"}

package/dist/types/commands/relocate.d.ts

@@ -0,0 +1,71 @@
+import * as z from "zod";
+import { InputOutputCliCommand } from "../utils/inputOutput.js";
+export declare const ArgsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    input: z.ZodString;
+}, {
+    output: z.ZodString;
+    overwrite: z.ZodOptional<z.ZodBoolean>;
+}>, {
+    from: z.ZodString;
+    to: z.ZodString;
+}>, "strip", z.ZodTypeAny, {
+    input: string;
+    output: string;
+    from: string;
+    to: string;
+    overwrite?: boolean | undefined;
+}, {
+    input: string;
+    output: string;
+    from: string;
+    to: string;
+    overwrite?: boolean | undefined;
+}>;
+export type ArgsSchemaType = typeof ArgsSchema;
+export type Args = z.infer<ArgsSchemaType>;
+export declare class Relocate extends InputOutputCliCommand<ArgsSchemaType> {
+    getArgSchema(): z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+        input: z.ZodString;
+    }, {
+        output: z.ZodString;
+        overwrite: z.ZodOptional<z.ZodBoolean>;
+    }>, {
+        from: z.ZodString;
+        to: z.ZodString;
+    }>, "strip", z.ZodTypeAny, {
+        input: string;
+        output: string;
+        from: string;
+        to: string;
+        overwrite?: boolean | undefined;
+    }, {
+        input: string;
+        output: string;
+        from: string;
+        to: string;
+        overwrite?: boolean | undefined;
+    }>;
+    getOptions(): {
+        [key: string]: import("yargs").Options;
+    } & {
+        input: {
+            description: string;
+        };
+        output: {
+            description: string;
+        };
+        from: {
+            string: boolean;
+            demand: boolean;
+            description: string;
+        };
+        to: {
+            description: string;
+            string: boolean;
+            demand: boolean;
+        };
+    };
+    _run(args: Args): Promise<void>;
+    getDescription(): string;
+}
+//# sourceMappingURL=relocate.d.ts.map

package/dist/types/commands/relocate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relocate.d.ts","sourceRoot":"","sources":["../../../src/commands/relocate.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAEN,qBAAqB,EACrB,MAAM,yBAAyB,CAAC;AAEjC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;EAGrB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,UAAU,CAAC;AAC/C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;AAE3C,qBAAa,QAAS,SAAQ,qBAAqB,CAAC,cAAc,CAAC;IAClD,YAAY;;;;;;;;;;;;;;;;;;;;;IAIZ,UAAU;;;;;;;;;;;;;;;;;;;;IAsBJ,IAAI,CAAC,IAAI,EAAE,IAAI;IAiDrB,cAAc,IAAI,MAAM;CAGxC"}

package/dist/types/commands/resize.d.ts

@@ -0,0 +1,69 @@
+import * as z from "zod";
+import { InputOutputCliCommand } from "../utils/inputOutput.js";
+export declare const ArgsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    input: z.ZodString;
+}, {
+    output: z.ZodString;
+    overwrite: z.ZodOptional<z.ZodBoolean>;
+}>, {
+    size: z.ZodNumber;
+    square: z.ZodOptional<z.ZodBoolean>;
+}>, "strip", z.ZodTypeAny, {
+    input: string;
+    output: string;
+    size: number;
+    overwrite?: boolean | undefined;
+    square?: boolean | undefined;
+}, {
+    input: string;
+    output: string;
+    size: number;
+    overwrite?: boolean | undefined;
+    square?: boolean | undefined;
+}>;
+export type ArgsSchemaType = typeof ArgsSchema;
+export type Args = z.infer<ArgsSchemaType>;
+export declare class Resize extends InputOutputCliCommand<ArgsSchemaType> {
+    getArgSchema(): z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+        input: z.ZodString;
+    }, {
+        output: z.ZodString;
+        overwrite: z.ZodOptional<z.ZodBoolean>;
+    }>, {
+        size: z.ZodNumber;
+        square: z.ZodOptional<z.ZodBoolean>;
+    }>, "strip", z.ZodTypeAny, {
+        input: string;
+        output: string;
+        size: number;
+        overwrite?: boolean | undefined;
+        square?: boolean | undefined;
+    }, {
+        input: string;
+        output: string;
+        size: number;
+        overwrite?: boolean | undefined;
+        square?: boolean | undefined;
+    }>;
+    getOptions(): {
+        [key: string]: import("yargs").Options;
+    } & {
+        input: {
+            description: string;
+        };
+        output: {
+            description: string;
+        };
+        size: {
+            number: boolean;
+            description: string;
+        };
+        square: {
+            boolean: boolean;
+            description: string;
+        };
+    };
+    _run(args: Args): Promise<void>;
+    getDescription(): string;
+}
+//# sourceMappingURL=resize.d.ts.map

package/dist/types/commands/resize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize.d.ts","sourceRoot":"","sources":["../../../src/commands/resize.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAEN,qBAAqB,EACrB,MAAM,yBAAyB,CAAC;AAEjC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;EAGrB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,UAAU,CAAC;AAC/C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;AAE3C,qBAAa,MAAO,SAAQ,qBAAqB,CAAC,cAAc,CAAC;IAChD,YAAY;;;;;;;;;;;;;;;;;;;;;IAIZ,UAAU;;;;;;;;;;;;;;;;;;IAuBJ,IAAI,CAAC,IAAI,EAAE,IAAI;IAuGrB,cAAc,IAAI,MAAM;CAGxC"}

package/dist/types/dummy.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dummy.d.ts.map

package/dist/types/dummy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dummy.d.ts","sourceRoot":"","sources":["../../src/dummy.ts"],"names":[],"mappings":""}

package/dist/types/errorSites.d.ts

@@ -0,0 +1,29 @@
+declare module "@prosopo/common" {
+    interface ErrorSites {
+        "DSFS-1": true;
+        "DSFS-2": true;
+        "DSFS-3": true;
+        "DSFS-4": true;
+        "DSFS-5": true;
+        "DSFS-6": true;
+        "DSFS-7": true;
+        "DSFS-8": true;
+        "DSFS-9": true;
+        "DSFS-10": true;
+        "DSFS-11": true;
+        "DSFS-12": true;
+        "DSFS-13": true;
+        "DSFS-14": true;
+        "DSFS-15": true;
+        "DSFS-16": true;
+        "DSFS-17": true;
+        "DSFS-18": true;
+        "DSFS-19": true;
+        "DSFS-20": true;
+        "DSFS-21": true;
+        "DSFS-22": true;
+        "DSFS-23": true;
+    }
+}
+export {};
+//# sourceMappingURL=errorSites.d.ts.map

package/dist/types/errorSites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorSites.d.ts","sourceRoot":"","sources":["../../src/errorSites.ts"],"names":[],"mappings":"AAcA,OAAO,QAAQ,iBAAiB,CAAC;IAChC,UAAU,UAAU;QACnB,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,QAAQ,EAAE,IAAI,CAAC;QACf,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;QAChB,SAAS,EAAE,IAAI,CAAC;KAChB;CACD;AAED,OAAO,EAAE,CAAC"}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./cli/cli.js";
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/types/tests/lodash.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lodash.unit.test.d.ts.map

package/dist/types/tests/lodash.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lodash.unit.test.d.ts","sourceRoot":"","sources":["../../../src/tests/lodash.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/mocked.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mocked.unit.test.d.ts.map

package/dist/types/tests/mocked.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mocked.unit.test.d.ts","sourceRoot":"","sources":["../../../src/tests/mocked.unit.test.ts"],"names":[],"mappings":""}

package/dist/types/tests/utils.d.ts

@@ -0,0 +1,37 @@
+import { type CaptchasContainer } from "@prosopo/types";
+export declare function fsWalk(pth: string, options?: {
+    filesFirst?: boolean;
+}): Generator<string>;
+export declare const fsEq: (pth1: string, pth2: string) => boolean;
+export declare const readDataJson: (pth: string) => {
+    items: {
+        type: import("@prosopo/types").CaptchaItemTypes;
+        hash: string;
+        data: string;
+        label?: string | undefined;
+    }[];
+};
+export declare const readCaptchasJson: (pth: string) => {
+    captchas: {
+        items: {
+            type: import("@prosopo/types").CaptchaItemTypes;
+            hash: string;
+            data: string;
+        }[];
+        salt: string;
+        target: string;
+        captchaId?: string | undefined;
+        captchaContentId?: string | undefined;
+        solution?: number[] | undefined;
+        unlabelled?: number[] | undefined;
+        timeLimit?: number | undefined;
+    }[];
+    format: import("@prosopo/types").CaptchaTypes;
+};
+export declare const captchasEqFs: (pth1: string, pth2: string) => boolean;
+export declare const captchasEq: (first: CaptchasContainer, second: CaptchasContainer) => boolean;
+export declare const REPO_PLACEHOLDER = "${repo}";
+export declare const REPO_DIR: string;
+export declare const substituteRepoDir: (fixture: string, dest: string) => string;
+export declare const readJson: (pth: string, replace?: [string, string]) => unknown;
+//# sourceMappingURL=utils.d.ts.map

package/dist/types/tests/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/tests/utils.ts"],"names":[],"mappings":"AAeA,OAAO,EACN,KAAK,iBAAiB,EAGtB,MAAM,gBAAgB,CAAC;AAIxB,wBAAiB,MAAM,CACtB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE;IACT,UAAU,CAAC,EAAE,OAAO,CAAC;CACrB,GACC,SAAS,CAAC,MAAM,CAAC,CAcnB;AAGD,eAAO,MAAM,IAAI,SAAU,MAAM,QAAQ,MAAM,YAiC9C,CAAC;AAEF,eAAO,MAAM,YAAY,QAAS,MAAM;;;;;aAiEo3c,CAAC;;CA3D55c,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAS,MAAM;;;;;;;;;iBAyDizjB,CAAC;wBAA8C,CAAC;gBAAsC,CAAC;kBAA0C,CAAC;iBAAyC,CAAC;;;CApDxgkB,CAAC;AAEF,eAAO,MAAM,YAAY,SAAU,MAAM,QAAQ,MAAM,YAItD,CAAC;AAEF,eAAO,MAAM,UAAU,UACf,iBAAiB,UAChB,iBAAiB,YAoBzB,CAAC;AAEF,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAE1C,eAAO,MAAM,QAAQ,QAAyC,CAAC;AAI/D,eAAO,MAAM,iBAAiB,YAAa,MAAM,QAAQ,MAAM,KAAG,MAKjE,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAS,MAAM,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,OAMlE,CAAC"}

package/dist/types/utils/input.d.ts

@@ -0,0 +1,24 @@
+import * as z from "zod";
+import { CliCommand } from "../cli/cliCommand.js";
+export declare const InputArgsSchema: z.ZodObject<{
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+}, {
+    input: string;
+}>;
+export type InputArgs = z.infer<typeof InputArgsSchema>;
+export declare class InputCliCommand<T extends typeof InputArgsSchema> extends CliCommand<T> {
+    getArgSchema(): T;
+    getDescription(): string;
+    getOptions(): {
+        input: {
+            string: boolean;
+            alias: string;
+            demand: boolean;
+            description: string;
+        };
+    };
+    _check(args: InputArgs): Promise<void>;
+}
+//# sourceMappingURL=input.d.ts.map

package/dist/types/utils/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../../src/utils/input.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,eAAO,MAAM,eAAe;;;;;;EAE1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,qBAAa,eAAe,CAC3B,CAAC,SAAS,OAAO,eAAe,CAC/B,SAAQ,UAAU,CAAC,CAAC,CAAC;IACN,YAAY,IAAI,CAAC;IAGjB,cAAc,IAAI,MAAM;IAGxB,UAAU;;;;;;;;IAWJ,MAAM,CAAC,IAAI,EAAE,SAAS;CAY5C"}

package/dist/types/utils/inputOutput.d.ts

@@ -0,0 +1,21 @@
+import type * as z from "zod";
+import { CliCommandComposite } from "../cli/cliCommandComposite.js";
+export declare const InputOutputArgsSchema: z.ZodObject<z.objectUtil.extendShape<{
+    input: z.ZodString;
+}, {
+    output: z.ZodString;
+    overwrite: z.ZodOptional<z.ZodBoolean>;
+}>, "strip", z.ZodTypeAny, {
+    input: string;
+    output: string;
+    overwrite?: boolean | undefined;
+}, {
+    input: string;
+    output: string;
+    overwrite?: boolean | undefined;
+}>;
+export type InputOutputArgs = z.infer<typeof InputOutputArgsSchema>;
+export declare abstract class InputOutputCliCommand<T extends typeof InputOutputArgsSchema> extends CliCommandComposite<T> {
+    constructor();
+}
+//# sourceMappingURL=inputOutput.d.ts.map

package/dist/types/utils/inputOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputOutput.d.ts","sourceRoot":"","sources":["../../../src/utils/inputOutput.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAC;AAC9B,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAIpE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;EAA0C,CAAC;AAE7E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,8BAAsB,qBAAqB,CAC1C,CAAC,SAAS,OAAO,qBAAqB,CACrC,SAAQ,mBAAmB,CAAC,CAAC,CAAC;;CAI/B"}

package/dist/types/utils/output.d.ts

@@ -0,0 +1,36 @@
+import { type infer as zInfer } from "zod";
+import { CliCommand } from "../cli/cliCommand.js";
+export declare const OutputArgsSchema: import("zod").ZodObject<{
+    output: import("zod").ZodString;
+    overwrite: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, "strip", import("zod").ZodTypeAny, {
+    output: string;
+    overwrite?: boolean | undefined;
+}, {
+    output: string;
+    overwrite?: boolean | undefined;
+}>;
+export type OutputArgs = zInfer<typeof OutputArgsSchema>;
+export declare class OutputCliCommand<T extends typeof OutputArgsSchema> extends CliCommand<T> {
+    #private;
+    outputExists(): boolean;
+    getArgSchema(): T;
+    getDescription(): string;
+    getOptions(): {
+        [key: string]: import("yargs").Options;
+    } & {
+        output: {
+            alias: string;
+            string: boolean;
+            demand: boolean;
+            description: string;
+        };
+        overwrite: {
+            boolean: boolean;
+            description: string;
+        };
+    };
+    _check(args: OutputArgs): Promise<void>;
+    _run(args: OutputArgs): Promise<void>;
+}
+//# sourceMappingURL=output.d.ts.map

package/dist/types/utils/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../src/utils/output.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,KAAK,KAAK,IAAI,MAAM,EAAE,MAAM,KAAK,CAAC;AAcpE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,eAAO,MAAM,gBAAgB;;;;;;;;;EAG3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEzD,qBAAa,gBAAgB,CAC5B,CAAC,SAAS,OAAO,gBAAgB,CAChC,SAAQ,UAAU,CAAC,CAAC,CAAC;;IAGf,YAAY;IAIH,YAAY,IAAI,CAAC;IAGjB,cAAc,IAAI,MAAM;IAGxB,UAAU;;;;;;;;;;;;;;IAeJ,MAAM,CAAC,IAAI,EAAE,UAAU;IAmBvB,IAAI,CAAC,IAAI,EAAE,UAAU;CAS3C"}