@taqueria/protocol 0.16.0 → 0.19.2

package/ParsedTemplate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsedTemplate.d.ts","sourceRoot":"","sources":["ParsedTemplate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMM,CAAC;AAK7B,eAAO,MAAiB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK/C,CAAC;AAEH,oBAAY,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AACrE,oBAAY,CAAC,GAAG,cAAc,CAAC;AAE/B,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC"}

package/ParsedTemplate.js

@@ -0,0 +1,71 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ParsedTemplate.ts
+var ParsedTemplate_exports = {};
+__export(ParsedTemplate_exports, {
+  create: () => create,
+  factory: () => factory,
+  generatedSchemas: () => generatedSchemas,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema2,
+  schemas: () => schemas2
+});
+module.exports = __toCommonJS(ParsedTemplate_exports);
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var PluginResponseEncoding = __toESM(require("@taqueria/protocol/PluginResponseEncoding"));
+var Template = __toESM(require("@taqueria/protocol/Template"));
+var import_zod = require("zod");
+var internalSchema2 = Template.internalSchema.extend({
+  handler: import_zod.z.string(),
+  encoding: PluginResponseEncoding.schemas.schema
+}).describe("ParsedTemplate");
+var rawSchema2 = Template.rawSchema.extend({
+  handler: import_zod.z.string(),
+  encoding: PluginResponseEncoding.schemas.schema
+}).describe("ParsedTemplate");
+var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
+  rawSchema: rawSchema2,
+  internalSchema: internalSchema2,
+  parseErrMsg: (value) => `Could not parse the following template: ${value}`,
+  unknownErrMsg: "Something went wrong trying to parse an template"
+});
+var { create, make, of } = factory;
+var schemas2 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  factory,
+  generatedSchemas,
+  make,
+  of,
+  rawSchema,
+  schemas
+});
+//# sourceMappingURL=ParsedTemplate.js.map

package/ParsedTemplate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ParsedTemplate.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';\nimport * as Template from '@taqueria/protocol/Template';\nimport { z } from 'zod';\n\nconst internalSchema = Template\n\t.internalSchema\n\t.extend({\n\t\thandler: z.string(),\n\t\tencoding: PluginResponseEncoding.schemas.schema,\n\t})\n\t.describe('ParsedTemplate');\n\nexport const rawSchema = Template\n\t.rawSchema\n\t.extend({\n\t\thandler: z.string(),\n\t\tencoding: PluginResponseEncoding.schemas.schema,\n\t})\n\t.describe('ParsedTemplate');\n\ntype RawInput = z.infer<typeof rawSchema>;\ntype Input = z.infer<typeof internalSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: (value: unknown) => `Could not parse the following template: ${value}`,\n\tunknownErrMsg: 'Something went wrong trying to parse an template',\n});\n\nexport type ParsedTemplate = z.infer<typeof generatedSchemas.schema>;\nexport type t = ParsedTemplate;\n\nexport const { create, make, of } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as ParsedTemplate),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAAA;AAAA,EAAA,eAAAC;AAAA;AAAA;AAAA,kBAAuB;AACvB,6BAAwC;AACxC,eAA0B;AAC1B,iBAAkB;AAElB,IAAMC,kBACJ,wBACA,OAAO;AAAA,EACP,SAAS,aAAE,OAAO;AAAA,EAClB,UAAiC,+BAAQ;AAC1C,CAAC,EACA,SAAS,gBAAgB;AAEpB,IAAMF,aACX,mBACA,OAAO;AAAA,EACP,SAAS,aAAE,OAAO;AAAA,EAClB,UAAiC,+BAAQ;AAC1C,CAAC,EACA,SAAS,gBAAgB;AAKpB,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAG,SAA4B;AAAA,EACjF,WAAAH;AAAA,EACA,gBAAAE;AAAA,EACA,aAAa,CAAC,UAAmB,2CAA2C;AAAA,EAC5E,eAAe;AAChB,CAAC;AAKM,IAAM,EAAE,QAAQ,MAAM,GAAG,IAAI;AAE7B,IAAMD,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAqB;AACvE;","names":["rawSchema","schemas","internalSchema","createType"]}

package/ParsedTemplate.mjs

@@ -0,0 +1,34 @@
+// ParsedTemplate.ts
+import createType from "@taqueria/protocol/Base";
+import * as PluginResponseEncoding from "@taqueria/protocol/PluginResponseEncoding";
+import * as Template from "@taqueria/protocol/Template";
+import { z } from "zod";
+var internalSchema2 = Template.internalSchema.extend({
+  handler: z.string(),
+  encoding: PluginResponseEncoding.schemas.schema
+}).describe("ParsedTemplate");
+var rawSchema2 = Template.rawSchema.extend({
+  handler: z.string(),
+  encoding: PluginResponseEncoding.schemas.schema
+}).describe("ParsedTemplate");
+var { schemas: generatedSchemas, factory } = createType({
+  rawSchema: rawSchema2,
+  internalSchema: internalSchema2,
+  parseErrMsg: (value) => `Could not parse the following template: ${value}`,
+  unknownErrMsg: "Something went wrong trying to parse an template"
+});
+var { create, make, of } = factory;
+var schemas2 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+export {
+  create,
+  factory,
+  generatedSchemas,
+  make,
+  of,
+  rawSchema2 as rawSchema,
+  schemas2 as schemas
+};
+//# sourceMappingURL=ParsedTemplate.mjs.map

package/ParsedTemplate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ParsedTemplate.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';\nimport * as Template from '@taqueria/protocol/Template';\nimport { z } from 'zod';\n\nconst internalSchema = Template\n\t.internalSchema\n\t.extend({\n\t\thandler: z.string(),\n\t\tencoding: PluginResponseEncoding.schemas.schema,\n\t})\n\t.describe('ParsedTemplate');\n\nexport const rawSchema = Template\n\t.rawSchema\n\t.extend({\n\t\thandler: z.string(),\n\t\tencoding: PluginResponseEncoding.schemas.schema,\n\t})\n\t.describe('ParsedTemplate');\n\ntype RawInput = z.infer<typeof rawSchema>;\ntype Input = z.infer<typeof internalSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: (value: unknown) => `Could not parse the following template: ${value}`,\n\tunknownErrMsg: 'Something went wrong trying to parse an template',\n});\n\nexport type ParsedTemplate = z.infer<typeof generatedSchemas.schema>;\nexport type t = ParsedTemplate;\n\nexport const { create, make, of } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as ParsedTemplate),\n};\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,YAAY,4BAA4B;AACxC,YAAY,cAAc;AAC1B,SAAS,SAAS;AAElB,IAAMA,kBACJ,wBACA,OAAO;AAAA,EACP,SAAS,EAAE,OAAO;AAAA,EAClB,UAAiC,+BAAQ;AAC1C,CAAC,EACA,SAAS,gBAAgB;AAEpB,IAAMC,aACX,mBACA,OAAO;AAAA,EACP,SAAS,EAAE,OAAO;AAAA,EAClB,UAAiC,+BAAQ;AAC1C,CAAC,EACA,SAAS,gBAAgB;AAKpB,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA4B;AAAA,EACjF,WAAAA;AAAA,EACA,gBAAAD;AAAA,EACA,aAAa,CAAC,UAAmB,2CAA2C;AAAA,EAC5E,eAAe;AAChB,CAAC;AAKM,IAAM,EAAE,QAAQ,MAAM,GAAG,IAAI;AAE7B,IAAME,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAqB;AACvE;","names":["internalSchema","rawSchema","schemas"]}

package/PersistentState.d.ts

@@ -0,0 +1,575 @@
+import { z } from 'zod';
+declare const internalOpSchema: z.ZodObject<{
+    hash: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
+        readonly __kind: any;
+    }, any>, string & {
+        readonly __kind: any;
+    }, any>;
+    time: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, number & {
+        readonly __kind: any;
+    }, any>, number & {
+        readonly __kind: any;
+    }, any>;
+    output: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    output?: unknown;
+    hash: string & {
+        readonly __kind: any;
+    };
+    time: number & {
+        readonly __kind: any;
+    };
+}, {
+    hash?: any;
+    time?: any;
+    output?: unknown;
+}>;
+declare const internalTaskSchema: z.ZodObject<{
+    task: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
+        readonly __kind: any;
+    }, any>, string & {
+        readonly __kind: any;
+    }, any>;
+    plugin: z.ZodString;
+    time: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, number & {
+        readonly __kind: any;
+    }, any>, number & {
+        readonly __kind: any;
+    }, any>;
+    output: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    output?: unknown;
+    plugin: string;
+    time: number & {
+        readonly __kind: any;
+    };
+    task: string & {
+        readonly __kind: any;
+    };
+}, {
+    time?: any;
+    output?: unknown;
+    task?: any;
+    plugin: string;
+}>;
+export declare type PersistedTask = z.infer<typeof internalTaskSchema>;
+export declare type PersistedOperation = z.infer<typeof internalOpSchema>;
+export declare const rawSchema: z.ZodObject<{
+    operations: z.ZodRecord<z.ZodString, z.ZodObject<{
+        hash: z.ZodString;
+        time: z.ZodNumber;
+        output: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        output?: unknown;
+        hash: string;
+        time: number;
+    }, {
+        output?: unknown;
+        hash: string;
+        time: number;
+    }>>;
+    tasks: z.ZodRecord<z.ZodString, z.ZodObject<{
+        task: z.ZodType<any, z.ZodTypeDef, any>;
+        plugin: z.ZodString;
+        time: z.ZodNumber;
+        output: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        output?: unknown;
+        task?: any;
+        plugin: string;
+        time: number;
+    }, {
+        output?: unknown;
+        task?: any;
+        plugin: string;
+        time: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    operations: Record<string, {
+        output?: unknown;
+        hash: string;
+        time: number;
+    }>;
+    tasks: Record<string, {
+        output?: unknown;
+        task?: any;
+        plugin: string;
+        time: number;
+    }>;
+}, {
+    operations: Record<string, {
+        output?: unknown;
+        hash: string;
+        time: number;
+    }>;
+    tasks: Record<string, {
+        output?: unknown;
+        task?: any;
+        plugin: string;
+        time: number;
+    }>;
+}>;
+export declare const internalSchema: z.ZodEffects<z.ZodObject<{
+    operations: z.ZodRecord<z.ZodString, z.ZodObject<{
+        hash: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
+            readonly __kind: any;
+        }, any>, string & {
+            readonly __kind: any;
+        }, any>;
+        time: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, number & {
+            readonly __kind: any;
+        }, any>, number & {
+            readonly __kind: any;
+        }, any>;
+        output: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        output?: unknown;
+        hash: string & {
+            readonly __kind: any;
+        };
+        time: number & {
+            readonly __kind: any;
+        };
+    }, {
+        hash?: any;
+        time?: any;
+        output?: unknown;
+    }>>;
+    tasks: z.ZodRecord<z.ZodString, z.ZodObject<{
+        task: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
+            readonly __kind: any;
+        }, any>, string & {
+            readonly __kind: any;
+        }, any>;
+        plugin: z.ZodString;
+        time: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, number & {
+            readonly __kind: any;
+        }, any>, number & {
+            readonly __kind: any;
+        }, any>;
+        output: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        output?: unknown;
+        plugin: string;
+        time: number & {
+            readonly __kind: any;
+        };
+        task: string & {
+            readonly __kind: any;
+        };
+    }, {
+        time?: any;
+        output?: unknown;
+        task?: any;
+        plugin: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    operations: Record<string, {
+        output?: unknown;
+        hash: string & {
+            readonly __kind: any;
+        };
+        time: number & {
+            readonly __kind: any;
+        };
+    }>;
+    tasks: Record<string, {
+        output?: unknown;
+        plugin: string;
+        time: number & {
+            readonly __kind: any;
+        };
+        task: string & {
+            readonly __kind: any;
+        };
+    }>;
+}, {
+    operations: Record<string, {
+        hash?: any;
+        time?: any;
+        output?: unknown;
+    }>;
+    tasks: Record<string, {
+        time?: any;
+        output?: unknown;
+        task?: any;
+        plugin: string;
+    }>;
+}>, {
+    operations: Record<string, {
+        output?: unknown;
+        hash: string & {
+            readonly __kind: any;
+        };
+        time: number & {
+            readonly __kind: any;
+        };
+    }>;
+    tasks: Record<string, {
+        output?: unknown;
+        plugin: string;
+        time: number & {
+            readonly __kind: any;
+        };
+        task: string & {
+            readonly __kind: any;
+        };
+    }>;
+}, {
+    operations: Record<string, {
+        hash?: any;
+        time?: any;
+        output?: unknown;
+    }>;
+    tasks: Record<string, {
+        time?: any;
+        output?: unknown;
+        task?: any;
+        plugin: string;
+    }>;
+}>;
+export declare const generatedSchemas: {
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
+        operations: Record<string, {
+            output?: unknown;
+            hash: string & {
+                readonly __kind: any;
+            };
+            time: number & {
+                readonly __kind: any;
+            };
+        }>;
+        tasks: Record<string, {
+            output?: unknown;
+            plugin: string;
+            time: number & {
+                readonly __kind: any;
+            };
+            task: string & {
+                readonly __kind: any;
+            };
+        }>;
+    } & {
+        readonly __kind: any;
+    }, any>;
+}, factory: {
+    make: (input: {
+        operations: Record<string, {
+            output?: unknown;
+            hash: string & {
+                readonly __kind: any;
+            };
+            time: number & {
+                readonly __kind: any;
+            };
+        }>;
+        tasks: Record<string, {
+            output?: unknown;
+            plugin: string;
+            time: number & {
+                readonly __kind: any;
+            };
+            task: string & {
+                readonly __kind: any;
+            };
+        }>;
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        operations: Record<string, {
+            output?: unknown;
+            hash: string & {
+                readonly __kind: any;
+            };
+            time: number & {
+                readonly __kind: any;
+            };
+        }>;
+        tasks: Record<string, {
+            output?: unknown;
+            plugin: string;
+            time: number & {
+                readonly __kind: any;
+            };
+            task: string & {
+                readonly __kind: any;
+            };
+        }>;
+    } & {
+        readonly __kind: any;
+    }>;
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        operations: Record<string, {
+            output?: unknown;
+            hash: string & {
+                readonly __kind: any;
+            };
+            time: number & {
+                readonly __kind: any;
+            };
+        }>;
+        tasks: Record<string, {
+            output?: unknown;
+            plugin: string;
+            time: number & {
+                readonly __kind: any;
+            };
+            task: string & {
+                readonly __kind: any;
+            };
+        }>;
+    } & {
+        readonly __kind: any;
+    }>;
+    create: (input: {
+        operations: Record<string, {
+            output?: unknown;
+            hash: string;
+            time: number;
+        }>;
+        tasks: Record<string, {
+            output?: unknown;
+            task?: any;
+            plugin: string;
+            time: number;
+        }>;
+    } | {
+        operations: Record<string, {
+            output?: unknown;
+            hash: string & {
+                readonly __kind: any;
+            };
+            time: number & {
+                readonly __kind: any;
+            };
+        }>;
+        tasks: Record<string, {
+            output?: unknown;
+            plugin: string;
+            time: number & {
+                readonly __kind: any;
+            };
+            task: string & {
+                readonly __kind: any;
+            };
+        }>;
+    }) => {
+        operations: Record<string, {
+            output?: unknown;
+            hash: string & {
+                readonly __kind: any;
+            };
+            time: number & {
+                readonly __kind: any;
+            };
+        }>;
+        tasks: Record<string, {
+            output?: unknown;
+            plugin: string;
+            time: number & {
+                readonly __kind: any;
+            };
+            task: string & {
+                readonly __kind: any;
+            };
+        }>;
+    } & {
+        readonly __kind: any;
+    };
+    from: (input: unknown) => {
+        operations: Record<string, {
+            output?: unknown;
+            hash: string & {
+                readonly __kind: any;
+            };
+            time: number & {
+                readonly __kind: any;
+            };
+        }>;
+        tasks: Record<string, {
+            output?: unknown;
+            plugin: string;
+            time: number & {
+                readonly __kind: any;
+            };
+            task: string & {
+                readonly __kind: any;
+            };
+        }>;
+    } & {
+        readonly __kind: any;
+    };
+};
+export declare type PersistentState = z.infer<typeof generatedSchemas.schema>;
+export declare type t = PersistentState;
+export declare type State = PersistentState;
+export declare const create: (input: {
+    operations: Record<string, {
+        output?: unknown;
+        hash: string;
+        time: number;
+    }>;
+    tasks: Record<string, {
+        output?: unknown;
+        task?: any;
+        plugin: string;
+        time: number;
+    }>;
+} | {
+    operations: Record<string, {
+        output?: unknown;
+        hash: string & {
+            readonly __kind: any;
+        };
+        time: number & {
+            readonly __kind: any;
+        };
+    }>;
+    tasks: Record<string, {
+        output?: unknown;
+        plugin: string;
+        time: number & {
+            readonly __kind: any;
+        };
+        task: string & {
+            readonly __kind: any;
+        };
+    }>;
+}) => {
+    operations: Record<string, {
+        output?: unknown;
+        hash: string & {
+            readonly __kind: any;
+        };
+        time: number & {
+            readonly __kind: any;
+        };
+    }>;
+    tasks: Record<string, {
+        output?: unknown;
+        plugin: string;
+        time: number & {
+            readonly __kind: any;
+        };
+        task: string & {
+            readonly __kind: any;
+        };
+    }>;
+} & {
+    readonly __kind: any;
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    operations: Record<string, {
+        output?: unknown;
+        hash: string & {
+            readonly __kind: any;
+        };
+        time: number & {
+            readonly __kind: any;
+        };
+    }>;
+    tasks: Record<string, {
+        output?: unknown;
+        plugin: string;
+        time: number & {
+            readonly __kind: any;
+        };
+        task: string & {
+            readonly __kind: any;
+        };
+    }>;
+} & {
+    readonly __kind: any;
+}>, make: (input: {
+    operations: Record<string, {
+        output?: unknown;
+        hash: string & {
+            readonly __kind: any;
+        };
+        time: number & {
+            readonly __kind: any;
+        };
+    }>;
+    tasks: Record<string, {
+        output?: unknown;
+        plugin: string;
+        time: number & {
+            readonly __kind: any;
+        };
+        task: string & {
+            readonly __kind: any;
+        };
+    }>;
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    operations: Record<string, {
+        output?: unknown;
+        hash: string & {
+            readonly __kind: any;
+        };
+        time: number & {
+            readonly __kind: any;
+        };
+    }>;
+    tasks: Record<string, {
+        output?: unknown;
+        plugin: string;
+        time: number & {
+            readonly __kind: any;
+        };
+        task: string & {
+            readonly __kind: any;
+        };
+    }>;
+} & {
+    readonly __kind: any;
+}>;
+export declare const schemas: {
+    schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
+        operations: Record<string, {
+            output?: unknown;
+            hash: string & {
+                readonly __kind: any;
+            };
+            time: number & {
+                readonly __kind: any;
+            };
+        }>;
+        tasks: Record<string, {
+            output?: unknown;
+            plugin: string;
+            time: number & {
+                readonly __kind: any;
+            };
+            task: string & {
+                readonly __kind: any;
+            };
+        }>;
+    } & {
+        readonly __kind: any;
+    }, any>, {
+        operations: Record<string, {
+            output?: unknown;
+            hash: string & {
+                readonly __kind: any;
+            };
+            time: number & {
+                readonly __kind: any;
+            };
+        }>;
+        tasks: Record<string, {
+            output?: unknown;
+            plugin: string;
+            time: number & {
+                readonly __kind: any;
+            };
+            task: string & {
+                readonly __kind: any;
+            };
+        }>;
+    } & {
+        readonly __kind: any;
+    }, any>;
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+};
+export {};
+//# sourceMappingURL=PersistentState.d.ts.map

package/PersistentState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistentState.d.ts","sourceRoot":"","sources":["PersistentState.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;EAIpB,CAAC;AAEH,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtB,CAAC;AAEH,oBAAY,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,oBAAY,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAElE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMxB,CAAC;AAMJ,eAAO,MAAiB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/C,CAAC;AAEH,oBAAY,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AACtE,oBAAY,CAAC,GAAG,eAAe,CAAC;AAChC,oBAAY,KAAK,GAAG,eAAe,CAAC;AAEpC,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;IAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC"}