@prosopo/datasets-fs 3.0.153 → 3.0.155

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

@@ -0,0 +1,114 @@
+import { type Item, type LabelledItem } from "@prosopo/types";
+import * as z from "zod";
+import { OutputCliCommand } from "../utils/output.js";
+export declare const ArgsSchema: z.ZodObject<{
+    output: z.ZodString;
+} & {
+    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>;
+}, "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;
+}, {
+    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;
+}>;
+export type ArgsSchemaType = typeof ArgsSchema;
+export type Args = z.infer<ArgsSchemaType>;
+export declare abstract class Generate<T extends ArgsSchemaType> extends OutputCliCommand<T> {
+    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;
+        };
+    };
+    _check(args: Args): Promise<void>;
+    labelled: LabelledItem[];
+    unlabelled: Item[];
+    labels: string[];
+    labelledMapFile: string;
+    unlabelledMapFile: string;
+    labelToImages: {
+        [label: string]: Item[];
+    };
+    targets: string[];
+    saltRounds: number;
+    private loadData;
+    private loadLabels;
+    _run(args: Args): Promise<void>;
+}
+export declare const checkDuplicates: (labelled: LabelledItem[], unlabelled: Item[], options: {
+    allowDuplicatesLabelled?: boolean;
+    allowDuplicatesUnlabelled?: boolean;
+}) => void;
+//# sourceMappingURL=generate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/commands/generate.ts"],"names":[],"mappings":"AAEA,OAAO,EAEN,KAAK,IAAI,EAET,KAAK,YAAY,EAEjB,MAAM,gBAAgB,CAAC;AAexB,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAoB,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAExE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUrB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,UAAU,CAAC;AAC/C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;AAE3C,8BAAsB,QAAQ,CAC7B,CAAC,SAAS,cAAc,CACvB,SAAQ,gBAAgB,CAAC,CAAC,CAAC;IACZ,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6CJ,MAAM,CAAC,IAAI,EAAE,IAAI;IAsBvC,QAAQ,EAAE,YAAY,EAAE,CAAM;IAC9B,UAAU,EAAE,IAAI,EAAE,CAAM;IACxB,MAAM,EAAE,MAAM,EAAE,CAAM;IACtB,eAAe,SAAM;IACrB,iBAAiB,SAAM;IACvB,aAAa,EAAE;QAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,CAAA;KAAE,CAAM;IAChD,OAAO,EAAE,MAAM,EAAE,CAAM;IACvB,UAAU,SAAM;IAEhB,OAAO,CAAC,QAAQ;IAkChB,OAAO,CAAC,UAAU;IAmBI,IAAI,CAAC,IAAI,EAAE,IAAI;CAWrC;AAED,eAAO,MAAM,eAAe,aACjB,YAAY,EAAE,cACZ,IAAI,EAAE,WACT;IACR,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACpC,SAOD,CAAC"}

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

@@ -0,0 +1,177 @@
+import * as z from "zod";
+import { Generate } from "./generate.js";
+export declare const ArgsSchema: z.ZodObject<{
+    output: z.ZodString;
+} & {
+    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>;
+} & {
+    solved: z.ZodOptional<z.ZodNumber>;
+    unsolved: z.ZodOptional<z.ZodNumber>;
+    minCorrect: z.ZodOptional<z.ZodNumber>;
+    maxCorrect: 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;
+    solved?: number | undefined;
+    unsolved?: number | undefined;
+    minCorrect?: number | undefined;
+    maxCorrect?: 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;
+    solved?: number | undefined;
+    unsolved?: number | undefined;
+    minCorrect?: number | undefined;
+    maxCorrect?: number | undefined;
+}>;
+export type ArgsSchemaType = typeof ArgsSchema;
+export type Args = z.infer<ArgsSchemaType>;
+export declare class GenerateV1 extends Generate<ArgsSchemaType> {
+    getArgSchema(): z.ZodObject<{
+        output: z.ZodString;
+    } & {
+        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>;
+    } & {
+        solved: z.ZodOptional<z.ZodNumber>;
+        unsolved: z.ZodOptional<z.ZodNumber>;
+        minCorrect: z.ZodOptional<z.ZodNumber>;
+        maxCorrect: 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;
+        solved?: number | undefined;
+        unsolved?: number | undefined;
+        minCorrect?: number | undefined;
+        maxCorrect?: 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;
+        solved?: number | undefined;
+        unsolved?: number | undefined;
+        minCorrect?: number | undefined;
+        maxCorrect?: 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;
+        };
+    } & {
+        solved: {
+            description: string;
+            number: boolean;
+        };
+        unsolved: {
+            description: string;
+            number: boolean;
+        };
+        minCorrect: {
+            description: string;
+            number: boolean;
+        };
+        maxCorrect: {
+            description: string;
+            number: boolean;
+        };
+    };
+    private generateSolved;
+    private generateUnsolved;
+    _run(args: Args): Promise<void>;
+}
+//# sourceMappingURL=generateV1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateV1.d.ts","sourceRoot":"","sources":["../../../src/commands/generateV1.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAE,QAAQ,EAAoC,MAAM,eAAe,CAAC;AAE3E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKrB,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;IACvC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIZ,cAAc,IAAI,MAAM;IAIxB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqB1B,OAAO,CAAC,cAAc;IA+FtB,OAAO,CAAC,gBAAgB;IAwDF,IAAI,CAAC,IAAI,EAAE,IAAI;CA6CrC"}

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

@@ -0,0 +1,187 @@
+import * as z from "zod";
+import { Generate } from "./generate.js";
+export declare const ArgsSchema: z.ZodObject<{
+    output: z.ZodString;
+} & {
+    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<{
+        output: z.ZodString;
+    } & {
+        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<{
+    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<{
+        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<{
+    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<{
+        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<{
+    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<{
+        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"}