@taqueria/protocol 0.25.0-alpha → 0.25.3-alpha

package/out/types/Template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Template.d.ts","sourceRoot":"","sources":["Template.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAA4E,MAAM,6BAA6B,CAAC;AACjI,OAAO,EAAE,cAAc,EAAmB,MAAM,SAAS,CAAC;AAE1D,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,QAAQ,IAAI,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAGjF,YAAY,EAAE,cAAc,IAAI,QAAQ,EAAE,CAAC;AAE3C,eAAO,MAAM,IAAI,UAAW,OAAO,KAAG,cAoBrC,CAAC;AAEF,eAAO,MAAM,MAAM,UAAW,QAAQ,KAAG,cAA6B,CAAC;AAEvE,eAAO,MAAM,EAAE,UAAW,OAAO,KAAG,eAAe,QAAQ,EAAE,cAAc,CAO1E,CAAC;AAEF,eAAO,MAAM,IAAI,UAAW,KAAK,cAAc,EAAE,QAAQ,CAAC,KAAG,eAAe,QAAQ,EAAE,cAAc,CAAc,CAAC;AAGnH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC;AACF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAoB,CAAC;AAC3C,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiB,CAAC;AAE7C,MAAM,MAAM,CAAC,GAAG,cAAc,CAAC"}

package/out/types/Template.js

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// out/types/Template.ts
+var Template_exports = {};
+__export(Template_exports, {
+  create: () => create,
+  from: () => from,
+  internalSchema: () => internalSchema,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas
+});
+module.exports = __toCommonJS(Template_exports);
+var import_TaqError = require("@taqueria/protocol/TaqError");
+var import_fluture = require("fluture");
+var import_zod = require("zod");
+var import_types_zod = require("@taqueria/protocol/out/types-zod");
+var from = (input) => {
+  try {
+    return import_types_zod.templateSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path = issue.path.join(" \u2192 ");
+          const msg = path + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Template is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw (0, import_TaqError.toParseErr)(previous, validationErr);
+    }
+    throw (0, import_TaqError.toParseUnknownErr)(previous, "There was a problem trying to parse a Template.");
+  }
+};
+var create = (input) => from(input);
+var of = (input) => {
+  try {
+    return (0, import_fluture.resolve)(from(input));
+  } catch (err) {
+    return (0, import_fluture.reject)(err);
+  }
+};
+var make = (input) => of(input);
+var schemas = {
+  rawSchema: import_types_zod.templateSchema,
+  schema: import_types_zod.templateSchema.transform((val) => val)
+};
+var rawSchema = schemas.rawSchema;
+var internalSchema = import_types_zod.templateSchema;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  from,
+  internalSchema,
+  make,
+  of,
+  rawSchema,
+  schemas
+});
+//# sourceMappingURL=Template.js.map

package/out/types/Template.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Template.ts"],"sourcesContent":["// Generated file: Do not edit \n// generated from @taqueria-protocol-types\n    \nimport { TaqError, toFutureParseErr, toFutureParseUnknownErr, toParseErr, toParseUnknownErr } from '@taqueria/protocol/TaqError';\nimport { FutureInstance, resolve, reject } from 'fluture';\nimport { ZodError } from 'zod';\nimport { Template } from '@taqueria/protocol/types';\nimport { Template as TemplateStrict } from '@taqueria/protocol/out/types-strict';\nimport { templateSchema } from '@taqueria/protocol/out/types-zod';\n\nexport type { TemplateStrict as Template };\n\nexport const from = (input: unknown): TemplateStrict => {\n\ttry {\n\t\treturn templateSchema.parse(input) as TemplateStrict;\n\t}\n\tcatch (previous: unknown) {\n\t\tif (previous instanceof ZodError) {\n\t\t\tconst msgs: string[] = previous.errors.reduce(\n\t\t\t\t(retval, issue) => {\n\t\t\t\t\tconst path = issue.path.join(' → ');\n\t\t\t\t\tconst msg = path + ': ' + issue.message;\n\t\t\t\t\treturn [...retval, msg];\n\t\t\t\t},\n\t\t\t\t[\"Template is invalid:\"],\n\t\t\t);\n\t\t\tconst validationErr = msgs.join('\\n') + '\\n';\n\t\t\tthrow toParseErr(previous, validationErr);\n\t\t}\n\t\tthrow toParseUnknownErr(previous, \"There was a problem trying to parse a Template.\")\n\t}\n    \n};\n\nexport const create = (input: Template): TemplateStrict => from(input);\n\nexport const of = (input: unknown): FutureInstance<TaqError, TemplateStrict> => {\n\ttry {\n\t\treturn resolve(from(input))\n\t}\n\tcatch (err){\n\t\treturn reject(err) as FutureInstance<TaqError, never>\n\t}\n};\n\nexport const make = (input: Omit<TemplateStrict, '__type'>): FutureInstance<TaqError, TemplateStrict> => of(input);\n\n// TEMP: for interoperation with old protocol types during transition\nexport const schemas = {\n\trawSchema: templateSchema,\n\tschema: templateSchema.transform(val => val as TemplateStrict),\n};\nexport const rawSchema = schemas.rawSchema;\nexport const internalSchema = templateSchema;\n\nexport type t = TemplateStrict;\n        "],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,sBAAmG;AACnG,qBAAgD;AAChD,iBAAyB;AAGzB,uBAA+B;AAIxB,IAAM,OAAO,CAAC,UAAmC;AACvD,MAAI;AACH,WAAO,gCAAe,MAAM,KAAK;AAAA,EAClC,SACO,UAAP;AACC,QAAI,oBAAoB,qBAAU;AACjC,YAAM,OAAiB,SAAS,OAAO;AAAA,QACtC,CAAC,QAAQ,UAAU;AAClB,gBAAM,OAAO,MAAM,KAAK,KAAK,UAAK;AAClC,gBAAM,MAAM,OAAO,OAAO,MAAM;AAChC,iBAAO,CAAC,GAAG,QAAQ,GAAG;AAAA,QACvB;AAAA,QACA,CAAC,sBAAsB;AAAA,MACxB;AACA,YAAM,gBAAgB,KAAK,KAAK,IAAI,IAAI;AACxC,gBAAM,4BAAW,UAAU,aAAa;AAAA,IACzC;AACA,cAAM,mCAAkB,UAAU,iDAAiD;AAAA,EACpF;AAED;AAEO,IAAM,SAAS,CAAC,UAAoC,KAAK,KAAK;AAE9D,IAAM,KAAK,CAAC,UAA6D;AAC/E,MAAI;AACH,eAAO,wBAAQ,KAAK,KAAK,CAAC;AAAA,EAC3B,SACO,KAAP;AACC,eAAO,uBAAO,GAAG;AAAA,EAClB;AACD;AAEO,IAAM,OAAO,CAAC,UAAoF,GAAG,KAAK;AAG1G,IAAM,UAAU;AAAA,EACtB,WAAW;AAAA,EACX,QAAQ,gCAAe,UAAU,SAAO,GAAqB;AAC9D;AACO,IAAM,YAAY,QAAQ;AAC1B,IAAM,iBAAiB;","names":[]}

package/out/types/Template.mjs

@@ -0,0 +1,49 @@
+// out/types/Template.ts
+import { toParseErr, toParseUnknownErr } from "@taqueria/protocol/TaqError";
+import { resolve, reject } from "fluture";
+import { ZodError } from "zod";
+import { templateSchema } from "@taqueria/protocol/out/types-zod";
+var from = (input) => {
+  try {
+    return templateSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path = issue.path.join(" \u2192 ");
+          const msg = path + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Template is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Template.");
+  }
+};
+var create = (input) => from(input);
+var of = (input) => {
+  try {
+    return resolve(from(input));
+  } catch (err) {
+    return reject(err);
+  }
+};
+var make = (input) => of(input);
+var schemas = {
+  rawSchema: templateSchema,
+  schema: templateSchema.transform((val) => val)
+};
+var rawSchema = schemas.rawSchema;
+var internalSchema = templateSchema;
+export {
+  create,
+  from,
+  internalSchema,
+  make,
+  of,
+  rawSchema,
+  schemas
+};
+//# sourceMappingURL=Template.mjs.map

package/out/types/Template.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Template.ts"],"sourcesContent":["// Generated file: Do not edit \n// generated from @taqueria-protocol-types\n    \nimport { TaqError, toFutureParseErr, toFutureParseUnknownErr, toParseErr, toParseUnknownErr } from '@taqueria/protocol/TaqError';\nimport { FutureInstance, resolve, reject } from 'fluture';\nimport { ZodError } from 'zod';\nimport { Template } from '@taqueria/protocol/types';\nimport { Template as TemplateStrict } from '@taqueria/protocol/out/types-strict';\nimport { templateSchema } from '@taqueria/protocol/out/types-zod';\n\nexport type { TemplateStrict as Template };\n\nexport const from = (input: unknown): TemplateStrict => {\n\ttry {\n\t\treturn templateSchema.parse(input) as TemplateStrict;\n\t}\n\tcatch (previous: unknown) {\n\t\tif (previous instanceof ZodError) {\n\t\t\tconst msgs: string[] = previous.errors.reduce(\n\t\t\t\t(retval, issue) => {\n\t\t\t\t\tconst path = issue.path.join(' → ');\n\t\t\t\t\tconst msg = path + ': ' + issue.message;\n\t\t\t\t\treturn [...retval, msg];\n\t\t\t\t},\n\t\t\t\t[\"Template is invalid:\"],\n\t\t\t);\n\t\t\tconst validationErr = msgs.join('\\n') + '\\n';\n\t\t\tthrow toParseErr(previous, validationErr);\n\t\t}\n\t\tthrow toParseUnknownErr(previous, \"There was a problem trying to parse a Template.\")\n\t}\n    \n};\n\nexport const create = (input: Template): TemplateStrict => from(input);\n\nexport const of = (input: unknown): FutureInstance<TaqError, TemplateStrict> => {\n\ttry {\n\t\treturn resolve(from(input))\n\t}\n\tcatch (err){\n\t\treturn reject(err) as FutureInstance<TaqError, never>\n\t}\n};\n\nexport const make = (input: Omit<TemplateStrict, '__type'>): FutureInstance<TaqError, TemplateStrict> => of(input);\n\n// TEMP: for interoperation with old protocol types during transition\nexport const schemas = {\n\trawSchema: templateSchema,\n\tschema: templateSchema.transform(val => val as TemplateStrict),\n};\nexport const rawSchema = schemas.rawSchema;\nexport const internalSchema = templateSchema;\n\nexport type t = TemplateStrict;\n        "],"mappings":";AAGA,SAA8D,YAAY,yBAAyB;AACnG,SAAyB,SAAS,cAAc;AAChD,SAAS,gBAAgB;AAGzB,SAAS,sBAAsB;AAIxB,IAAM,OAAO,CAAC,UAAmC;AACvD,MAAI;AACH,WAAO,eAAe,MAAM,KAAK;AAAA,EAClC,SACO,UAAP;AACC,QAAI,oBAAoB,UAAU;AACjC,YAAM,OAAiB,SAAS,OAAO;AAAA,QACtC,CAAC,QAAQ,UAAU;AAClB,gBAAM,OAAO,MAAM,KAAK,KAAK,UAAK;AAClC,gBAAM,MAAM,OAAO,OAAO,MAAM;AAChC,iBAAO,CAAC,GAAG,QAAQ,GAAG;AAAA,QACvB;AAAA,QACA,CAAC,sBAAsB;AAAA,MACxB;AACA,YAAM,gBAAgB,KAAK,KAAK,IAAI,IAAI;AACxC,YAAM,WAAW,UAAU,aAAa;AAAA,IACzC;AACA,UAAM,kBAAkB,UAAU,iDAAiD;AAAA,EACpF;AAED;AAEO,IAAM,SAAS,CAAC,UAAoC,KAAK,KAAK;AAE9D,IAAM,KAAK,CAAC,UAA6D;AAC/E,MAAI;AACH,WAAO,QAAQ,KAAK,KAAK,CAAC;AAAA,EAC3B,SACO,KAAP;AACC,WAAO,OAAO,GAAG;AAAA,EAClB;AACD;AAEO,IAAM,OAAO,CAAC,UAAoF,GAAG,KAAK;AAG1G,IAAM,UAAU;AAAA,EACtB,WAAW;AAAA,EACX,QAAQ,eAAe,UAAU,SAAO,GAAqB;AAC9D;AACO,IAAM,YAAY,QAAQ;AAC1B,IAAM,iBAAiB;","names":[]}

package/out/types/Timestamp.d.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// out/types/Timestamp.d.ts
+var Timestamp_d_exports = {};
+module.exports = __toCommonJS(Timestamp_d_exports);
+//# sourceMappingURL=Timestamp.d.js.map

package/out/types/Timestamp.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Timestamp.ts"],"sourcesContent":["// Generated file: Do not edit \n// generated from @taqueria-protocol-types\n    \nimport { TaqError, toFutureParseErr, toFutureParseUnknownErr, toParseErr, toParseUnknownErr } from '@taqueria/protocol/TaqError';\nimport { FutureInstance, resolve, reject } from 'fluture';\nimport { ZodError } from 'zod';\nimport { Timestamp } from '@taqueria/protocol/types';\nimport { Timestamp as TimestampStrict } from '@taqueria/protocol/out/types-strict';\nimport { timestampSchema } from '@taqueria/protocol/out/types-zod';\n\nexport type { TimestampStrict as Timestamp };\n\nexport const from = (input: unknown): TimestampStrict => {\n\ttry {\n\t\treturn timestampSchema.parse(input) as TimestampStrict;\n\t}\n\tcatch (previous: unknown) {\n\t\tif (previous instanceof ZodError) {\n\t\t\tconst msgs: string[] = previous.errors.reduce(\n\t\t\t\t(retval, issue) => {\n\t\t\t\t\tconst path = issue.path.join(' → ');\n\t\t\t\t\tconst msg = path + ': ' + issue.message;\n\t\t\t\t\treturn [...retval, msg];\n\t\t\t\t},\n\t\t\t\t[\"Timestamp is invalid:\"],\n\t\t\t);\n\t\t\tconst validationErr = msgs.join('\\n') + '\\n';\n\t\t\tthrow toParseErr(previous, validationErr);\n\t\t}\n\t\tthrow toParseUnknownErr(previous, \"There was a problem trying to parse a Timestamp.\")\n\t}\n    \n};\n\nexport const create = (input: Timestamp): TimestampStrict => from(input);\n\nexport const of = (input: unknown): FutureInstance<TaqError, TimestampStrict> => {\n\ttry {\n\t\treturn resolve(from(input))\n\t}\n\tcatch (err){\n\t\treturn reject(err) as FutureInstance<TaqError, never>\n\t}\n};\n\nexport const make = (input: Omit<TimestampStrict, '__type'>): FutureInstance<TaqError, TimestampStrict> => of(input);\n\n// TEMP: for interoperation with old protocol types during transition\nexport const schemas = {\n\trawSchema: timestampSchema,\n\tschema: timestampSchema.transform(val => val as TimestampStrict),\n};\nexport const rawSchema = schemas.rawSchema;\nexport const internalSchema = timestampSchema;\n\nexport type t = TimestampStrict;\n        "],"mappings":";;;;;;;;;;;;;;;;AAGA;;","names":[]}

package/out/types/Timestamp.d.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=Timestamp.d.mjs.map

package/out/types/Timestamp.d.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/out/types/Timestamp.d.ts

@@ -0,0 +1,17 @@
+import { TaqError } from '@taqueria/protocol/TaqError';
+import { FutureInstance } from 'fluture';
+import { Timestamp } from '@taqueria/protocol/types';
+import { Timestamp as TimestampStrict } from '@taqueria/protocol/out/types-strict';
+export type { TimestampStrict as Timestamp };
+export declare const from: (input: unknown) => TimestampStrict;
+export declare const create: (input: Timestamp) => TimestampStrict;
+export declare const of: (input: unknown) => FutureInstance<TaqError, TimestampStrict>;
+export declare const make: (input: Omit<TimestampStrict, '__type'>) => FutureInstance<TaqError, TimestampStrict>;
+export declare const schemas: {
+    rawSchema: import("zod").ZodNumber;
+    schema: import("zod").ZodEffects<import("zod").ZodNumber, TimestampStrict, number>;
+};
+export declare const rawSchema: import("zod").ZodNumber;
+export declare const internalSchema: import("zod").ZodNumber;
+export type t = TimestampStrict;
+//# sourceMappingURL=Timestamp.d.ts.map

package/out/types/Timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Timestamp.d.ts","sourceRoot":"","sources":["Timestamp.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAA4E,MAAM,6BAA6B,CAAC;AACjI,OAAO,EAAE,cAAc,EAAmB,MAAM,SAAS,CAAC;AAE1D,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,SAAS,IAAI,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAGnF,YAAY,EAAE,eAAe,IAAI,SAAS,EAAE,CAAC;AAE7C,eAAO,MAAM,IAAI,UAAW,OAAO,KAAG,eAoBrC,CAAC;AAEF,eAAO,MAAM,MAAM,UAAW,SAAS,KAAG,eAA8B,CAAC;AAEzE,eAAO,MAAM,EAAE,UAAW,OAAO,KAAG,eAAe,QAAQ,EAAE,eAAe,CAO3E,CAAC;AAEF,eAAO,MAAM,IAAI,UAAW,KAAK,eAAe,EAAE,QAAQ,CAAC,KAAG,eAAe,QAAQ,EAAE,eAAe,CAAc,CAAC;AAGrH,eAAO,MAAM,OAAO;;;CAGnB,CAAC;AACF,eAAO,MAAM,SAAS,yBAAoB,CAAC;AAC3C,eAAO,MAAM,cAAc,yBAAkB,CAAC;AAE9C,MAAM,MAAM,CAAC,GAAG,eAAe,CAAC"}

package/out/types/Timestamp.js

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// out/types/Timestamp.ts
+var Timestamp_exports = {};
+__export(Timestamp_exports, {
+  create: () => create,
+  from: () => from,
+  internalSchema: () => internalSchema,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas
+});
+module.exports = __toCommonJS(Timestamp_exports);
+var import_TaqError = require("@taqueria/protocol/TaqError");
+var import_fluture = require("fluture");
+var import_zod = require("zod");
+var import_types_zod = require("@taqueria/protocol/out/types-zod");
+var from = (input) => {
+  try {
+    return import_types_zod.timestampSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path = issue.path.join(" \u2192 ");
+          const msg = path + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Timestamp is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw (0, import_TaqError.toParseErr)(previous, validationErr);
+    }
+    throw (0, import_TaqError.toParseUnknownErr)(previous, "There was a problem trying to parse a Timestamp.");
+  }
+};
+var create = (input) => from(input);
+var of = (input) => {
+  try {
+    return (0, import_fluture.resolve)(from(input));
+  } catch (err) {
+    return (0, import_fluture.reject)(err);
+  }
+};
+var make = (input) => of(input);
+var schemas = {
+  rawSchema: import_types_zod.timestampSchema,
+  schema: import_types_zod.timestampSchema.transform((val) => val)
+};
+var rawSchema = schemas.rawSchema;
+var internalSchema = import_types_zod.timestampSchema;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  from,
+  internalSchema,
+  make,
+  of,
+  rawSchema,
+  schemas
+});
+//# sourceMappingURL=Timestamp.js.map

package/out/types/Timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Timestamp.ts"],"sourcesContent":["// Generated file: Do not edit \n// generated from @taqueria-protocol-types\n    \nimport { TaqError, toFutureParseErr, toFutureParseUnknownErr, toParseErr, toParseUnknownErr } from '@taqueria/protocol/TaqError';\nimport { FutureInstance, resolve, reject } from 'fluture';\nimport { ZodError } from 'zod';\nimport { Timestamp } from '@taqueria/protocol/types';\nimport { Timestamp as TimestampStrict } from '@taqueria/protocol/out/types-strict';\nimport { timestampSchema } from '@taqueria/protocol/out/types-zod';\n\nexport type { TimestampStrict as Timestamp };\n\nexport const from = (input: unknown): TimestampStrict => {\n\ttry {\n\t\treturn timestampSchema.parse(input) as TimestampStrict;\n\t}\n\tcatch (previous: unknown) {\n\t\tif (previous instanceof ZodError) {\n\t\t\tconst msgs: string[] = previous.errors.reduce(\n\t\t\t\t(retval, issue) => {\n\t\t\t\t\tconst path = issue.path.join(' → ');\n\t\t\t\t\tconst msg = path + ': ' + issue.message;\n\t\t\t\t\treturn [...retval, msg];\n\t\t\t\t},\n\t\t\t\t[\"Timestamp is invalid:\"],\n\t\t\t);\n\t\t\tconst validationErr = msgs.join('\\n') + '\\n';\n\t\t\tthrow toParseErr(previous, validationErr);\n\t\t}\n\t\tthrow toParseUnknownErr(previous, \"There was a problem trying to parse a Timestamp.\")\n\t}\n    \n};\n\nexport const create = (input: Timestamp): TimestampStrict => from(input);\n\nexport const of = (input: unknown): FutureInstance<TaqError, TimestampStrict> => {\n\ttry {\n\t\treturn resolve(from(input))\n\t}\n\tcatch (err){\n\t\treturn reject(err) as FutureInstance<TaqError, never>\n\t}\n};\n\nexport const make = (input: Omit<TimestampStrict, '__type'>): FutureInstance<TaqError, TimestampStrict> => of(input);\n\n// TEMP: for interoperation with old protocol types during transition\nexport const schemas = {\n\trawSchema: timestampSchema,\n\tschema: timestampSchema.transform(val => val as TimestampStrict),\n};\nexport const rawSchema = schemas.rawSchema;\nexport const internalSchema = timestampSchema;\n\nexport type t = TimestampStrict;\n        "],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,sBAAmG;AACnG,qBAAgD;AAChD,iBAAyB;AAGzB,uBAAgC;AAIzB,IAAM,OAAO,CAAC,UAAoC;AACxD,MAAI;AACH,WAAO,iCAAgB,MAAM,KAAK;AAAA,EACnC,SACO,UAAP;AACC,QAAI,oBAAoB,qBAAU;AACjC,YAAM,OAAiB,SAAS,OAAO;AAAA,QACtC,CAAC,QAAQ,UAAU;AAClB,gBAAM,OAAO,MAAM,KAAK,KAAK,UAAK;AAClC,gBAAM,MAAM,OAAO,OAAO,MAAM;AAChC,iBAAO,CAAC,GAAG,QAAQ,GAAG;AAAA,QACvB;AAAA,QACA,CAAC,uBAAuB;AAAA,MACzB;AACA,YAAM,gBAAgB,KAAK,KAAK,IAAI,IAAI;AACxC,gBAAM,4BAAW,UAAU,aAAa;AAAA,IACzC;AACA,cAAM,mCAAkB,UAAU,kDAAkD;AAAA,EACrF;AAED;AAEO,IAAM,SAAS,CAAC,UAAsC,KAAK,KAAK;AAEhE,IAAM,KAAK,CAAC,UAA8D;AAChF,MAAI;AACH,eAAO,wBAAQ,KAAK,KAAK,CAAC;AAAA,EAC3B,SACO,KAAP;AACC,eAAO,uBAAO,GAAG;AAAA,EAClB;AACD;AAEO,IAAM,OAAO,CAAC,UAAsF,GAAG,KAAK;AAG5G,IAAM,UAAU;AAAA,EACtB,WAAW;AAAA,EACX,QAAQ,iCAAgB,UAAU,SAAO,GAAsB;AAChE;AACO,IAAM,YAAY,QAAQ;AAC1B,IAAM,iBAAiB;","names":[]}

package/out/types/Timestamp.mjs

@@ -0,0 +1,49 @@
+// out/types/Timestamp.ts
+import { toParseErr, toParseUnknownErr } from "@taqueria/protocol/TaqError";
+import { resolve, reject } from "fluture";
+import { ZodError } from "zod";
+import { timestampSchema } from "@taqueria/protocol/out/types-zod";
+var from = (input) => {
+  try {
+    return timestampSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path = issue.path.join(" \u2192 ");
+          const msg = path + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Timestamp is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Timestamp.");
+  }
+};
+var create = (input) => from(input);
+var of = (input) => {
+  try {
+    return resolve(from(input));
+  } catch (err) {
+    return reject(err);
+  }
+};
+var make = (input) => of(input);
+var schemas = {
+  rawSchema: timestampSchema,
+  schema: timestampSchema.transform((val) => val)
+};
+var rawSchema = schemas.rawSchema;
+var internalSchema = timestampSchema;
+export {
+  create,
+  from,
+  internalSchema,
+  make,
+  of,
+  rawSchema,
+  schemas
+};
+//# sourceMappingURL=Timestamp.mjs.map

package/out/types/Timestamp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Timestamp.ts"],"sourcesContent":["// Generated file: Do not edit \n// generated from @taqueria-protocol-types\n    \nimport { TaqError, toFutureParseErr, toFutureParseUnknownErr, toParseErr, toParseUnknownErr } from '@taqueria/protocol/TaqError';\nimport { FutureInstance, resolve, reject } from 'fluture';\nimport { ZodError } from 'zod';\nimport { Timestamp } from '@taqueria/protocol/types';\nimport { Timestamp as TimestampStrict } from '@taqueria/protocol/out/types-strict';\nimport { timestampSchema } from '@taqueria/protocol/out/types-zod';\n\nexport type { TimestampStrict as Timestamp };\n\nexport const from = (input: unknown): TimestampStrict => {\n\ttry {\n\t\treturn timestampSchema.parse(input) as TimestampStrict;\n\t}\n\tcatch (previous: unknown) {\n\t\tif (previous instanceof ZodError) {\n\t\t\tconst msgs: string[] = previous.errors.reduce(\n\t\t\t\t(retval, issue) => {\n\t\t\t\t\tconst path = issue.path.join(' → ');\n\t\t\t\t\tconst msg = path + ': ' + issue.message;\n\t\t\t\t\treturn [...retval, msg];\n\t\t\t\t},\n\t\t\t\t[\"Timestamp is invalid:\"],\n\t\t\t);\n\t\t\tconst validationErr = msgs.join('\\n') + '\\n';\n\t\t\tthrow toParseErr(previous, validationErr);\n\t\t}\n\t\tthrow toParseUnknownErr(previous, \"There was a problem trying to parse a Timestamp.\")\n\t}\n    \n};\n\nexport const create = (input: Timestamp): TimestampStrict => from(input);\n\nexport const of = (input: unknown): FutureInstance<TaqError, TimestampStrict> => {\n\ttry {\n\t\treturn resolve(from(input))\n\t}\n\tcatch (err){\n\t\treturn reject(err) as FutureInstance<TaqError, never>\n\t}\n};\n\nexport const make = (input: Omit<TimestampStrict, '__type'>): FutureInstance<TaqError, TimestampStrict> => of(input);\n\n// TEMP: for interoperation with old protocol types during transition\nexport const schemas = {\n\trawSchema: timestampSchema,\n\tschema: timestampSchema.transform(val => val as TimestampStrict),\n};\nexport const rawSchema = schemas.rawSchema;\nexport const internalSchema = timestampSchema;\n\nexport type t = TimestampStrict;\n        "],"mappings":";AAGA,SAA8D,YAAY,yBAAyB;AACnG,SAAyB,SAAS,cAAc;AAChD,SAAS,gBAAgB;AAGzB,SAAS,uBAAuB;AAIzB,IAAM,OAAO,CAAC,UAAoC;AACxD,MAAI;AACH,WAAO,gBAAgB,MAAM,KAAK;AAAA,EACnC,SACO,UAAP;AACC,QAAI,oBAAoB,UAAU;AACjC,YAAM,OAAiB,SAAS,OAAO;AAAA,QACtC,CAAC,QAAQ,UAAU;AAClB,gBAAM,OAAO,MAAM,KAAK,KAAK,UAAK;AAClC,gBAAM,MAAM,OAAO,OAAO,MAAM;AAChC,iBAAO,CAAC,GAAG,QAAQ,GAAG;AAAA,QACvB;AAAA,QACA,CAAC,uBAAuB;AAAA,MACzB;AACA,YAAM,gBAAgB,KAAK,KAAK,IAAI,IAAI;AACxC,YAAM,WAAW,UAAU,aAAa;AAAA,IACzC;AACA,UAAM,kBAAkB,UAAU,kDAAkD;AAAA,EACrF;AAED;AAEO,IAAM,SAAS,CAAC,UAAsC,KAAK,KAAK;AAEhE,IAAM,KAAK,CAAC,UAA8D;AAChF,MAAI;AACH,WAAO,QAAQ,KAAK,KAAK,CAAC;AAAA,EAC3B,SACO,KAAP;AACC,WAAO,OAAO,GAAG;AAAA,EAClB;AACD;AAEO,IAAM,OAAO,CAAC,UAAsF,GAAG,KAAK;AAG5G,IAAM,UAAU;AAAA,EACtB,WAAW;AAAA,EACX,QAAQ,gBAAgB,UAAU,SAAO,GAAsB;AAChE;AACO,IAAM,YAAY,QAAQ;AAC1B,IAAM,iBAAiB;","names":[]}

package/out/types/Tz.d.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// out/types/Tz.d.ts
+var Tz_d_exports = {};
+module.exports = __toCommonJS(Tz_d_exports);
+//# sourceMappingURL=Tz.d.js.map

package/out/types/Tz.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Tz.ts"],"sourcesContent":["// Generated file: Do not edit \n// generated from @taqueria-protocol-types\n    \nimport { TaqError, toFutureParseErr, toFutureParseUnknownErr, toParseErr, toParseUnknownErr } from '@taqueria/protocol/TaqError';\nimport { FutureInstance, resolve, reject } from 'fluture';\nimport { ZodError } from 'zod';\nimport { Tz } from '@taqueria/protocol/types';\nimport { Tz as TzStrict } from '@taqueria/protocol/out/types-strict';\nimport { tzSchema } from '@taqueria/protocol/out/types-zod';\n\nexport type { TzStrict as Tz };\n\nexport const from = (input: unknown): TzStrict => {\n\ttry {\n\t\treturn tzSchema.parse(input) as TzStrict;\n\t}\n\tcatch (previous: unknown) {\n\t\tif (previous instanceof ZodError) {\n\t\t\tconst msgs: string[] = previous.errors.reduce(\n\t\t\t\t(retval, issue) => {\n\t\t\t\t\tconst path = issue.path.join(' → ');\n\t\t\t\t\tconst msg = path + ': ' + issue.message;\n\t\t\t\t\treturn [...retval, msg];\n\t\t\t\t},\n\t\t\t\t[\"Tz is invalid:\"],\n\t\t\t);\n\t\t\tconst validationErr = msgs.join('\\n') + '\\n';\n\t\t\tthrow toParseErr(previous, validationErr);\n\t\t}\n\t\tthrow toParseUnknownErr(previous, \"There was a problem trying to parse a Tz.\")\n\t}\n    \n};\n\nexport const create = (input: Tz): TzStrict => from(input);\n\nexport const of = (input: unknown): FutureInstance<TaqError, TzStrict> => {\n\ttry {\n\t\treturn resolve(from(input))\n\t}\n\tcatch (err){\n\t\treturn reject(err) as FutureInstance<TaqError, never>\n\t}\n};\n\nexport const make = (input: Omit<TzStrict, '__type'>): FutureInstance<TaqError, TzStrict> => of(input);\n\n// TEMP: for interoperation with old protocol types during transition\nexport const schemas = {\n\trawSchema: tzSchema,\n\tschema: tzSchema.transform(val => val as TzStrict),\n};\nexport const rawSchema = schemas.rawSchema;\nexport const internalSchema = tzSchema;\n\nexport type t = TzStrict;\n        "],"mappings":";;;;;;;;;;;;;;;;AAGA;;","names":[]}

package/out/types/Tz.d.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=Tz.d.mjs.map

package/out/types/Tz.d.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/out/types/Tz.d.ts

@@ -0,0 +1,17 @@
+import { TaqError } from '@taqueria/protocol/TaqError';
+import { FutureInstance } from 'fluture';
+import { Tz } from '@taqueria/protocol/types';
+import { Tz as TzStrict } from '@taqueria/protocol/out/types-strict';
+export type { TzStrict as Tz };
+export declare const from: (input: unknown) => TzStrict;
+export declare const create: (input: Tz) => TzStrict;
+export declare const of: (input: unknown) => FutureInstance<TaqError, TzStrict>;
+export declare const make: (input: Omit<TzStrict, '__type'>) => FutureInstance<TaqError, TzStrict>;
+export declare const schemas: {
+    rawSchema: import("zod").ZodString;
+    schema: import("zod").ZodEffects<import("zod").ZodString, TzStrict, string>;
+};
+export declare const rawSchema: import("zod").ZodString;
+export declare const internalSchema: import("zod").ZodString;
+export type t = TzStrict;
+//# sourceMappingURL=Tz.d.ts.map

package/out/types/Tz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tz.d.ts","sourceRoot":"","sources":["Tz.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAA4E,MAAM,6BAA6B,CAAC;AACjI,OAAO,EAAE,cAAc,EAAmB,MAAM,SAAS,CAAC;AAE1D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,EAAE,IAAI,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAGrE,YAAY,EAAE,QAAQ,IAAI,EAAE,EAAE,CAAC;AAE/B,eAAO,MAAM,IAAI,UAAW,OAAO,KAAG,QAoBrC,CAAC;AAEF,eAAO,MAAM,MAAM,UAAW,EAAE,KAAG,QAAuB,CAAC;AAE3D,eAAO,MAAM,EAAE,UAAW,OAAO,KAAG,eAAe,QAAQ,EAAE,QAAQ,CAOpE,CAAC;AAEF,eAAO,MAAM,IAAI,UAAW,KAAK,QAAQ,EAAE,QAAQ,CAAC,KAAG,eAAe,QAAQ,EAAE,QAAQ,CAAc,CAAC;AAGvG,eAAO,MAAM,OAAO;;;CAGnB,CAAC;AACF,eAAO,MAAM,SAAS,yBAAoB,CAAC;AAC3C,eAAO,MAAM,cAAc,yBAAW,CAAC;AAEvC,MAAM,MAAM,CAAC,GAAG,QAAQ,CAAC"}

package/out/types/Tz.js

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// out/types/Tz.ts
+var Tz_exports = {};
+__export(Tz_exports, {
+  create: () => create,
+  from: () => from,
+  internalSchema: () => internalSchema,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas
+});
+module.exports = __toCommonJS(Tz_exports);
+var import_TaqError = require("@taqueria/protocol/TaqError");
+var import_fluture = require("fluture");
+var import_zod = require("zod");
+var import_types_zod = require("@taqueria/protocol/out/types-zod");
+var from = (input) => {
+  try {
+    return import_types_zod.tzSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path = issue.path.join(" \u2192 ");
+          const msg = path + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Tz is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw (0, import_TaqError.toParseErr)(previous, validationErr);
+    }
+    throw (0, import_TaqError.toParseUnknownErr)(previous, "There was a problem trying to parse a Tz.");
+  }
+};
+var create = (input) => from(input);
+var of = (input) => {
+  try {
+    return (0, import_fluture.resolve)(from(input));
+  } catch (err) {
+    return (0, import_fluture.reject)(err);
+  }
+};
+var make = (input) => of(input);
+var schemas = {
+  rawSchema: import_types_zod.tzSchema,
+  schema: import_types_zod.tzSchema.transform((val) => val)
+};
+var rawSchema = schemas.rawSchema;
+var internalSchema = import_types_zod.tzSchema;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  from,
+  internalSchema,
+  make,
+  of,
+  rawSchema,
+  schemas
+});
+//# sourceMappingURL=Tz.js.map

package/out/types/Tz.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Tz.ts"],"sourcesContent":["// Generated file: Do not edit \n// generated from @taqueria-protocol-types\n    \nimport { TaqError, toFutureParseErr, toFutureParseUnknownErr, toParseErr, toParseUnknownErr } from '@taqueria/protocol/TaqError';\nimport { FutureInstance, resolve, reject } from 'fluture';\nimport { ZodError } from 'zod';\nimport { Tz } from '@taqueria/protocol/types';\nimport { Tz as TzStrict } from '@taqueria/protocol/out/types-strict';\nimport { tzSchema } from '@taqueria/protocol/out/types-zod';\n\nexport type { TzStrict as Tz };\n\nexport const from = (input: unknown): TzStrict => {\n\ttry {\n\t\treturn tzSchema.parse(input) as TzStrict;\n\t}\n\tcatch (previous: unknown) {\n\t\tif (previous instanceof ZodError) {\n\t\t\tconst msgs: string[] = previous.errors.reduce(\n\t\t\t\t(retval, issue) => {\n\t\t\t\t\tconst path = issue.path.join(' → ');\n\t\t\t\t\tconst msg = path + ': ' + issue.message;\n\t\t\t\t\treturn [...retval, msg];\n\t\t\t\t},\n\t\t\t\t[\"Tz is invalid:\"],\n\t\t\t);\n\t\t\tconst validationErr = msgs.join('\\n') + '\\n';\n\t\t\tthrow toParseErr(previous, validationErr);\n\t\t}\n\t\tthrow toParseUnknownErr(previous, \"There was a problem trying to parse a Tz.\")\n\t}\n    \n};\n\nexport const create = (input: Tz): TzStrict => from(input);\n\nexport const of = (input: unknown): FutureInstance<TaqError, TzStrict> => {\n\ttry {\n\t\treturn resolve(from(input))\n\t}\n\tcatch (err){\n\t\treturn reject(err) as FutureInstance<TaqError, never>\n\t}\n};\n\nexport const make = (input: Omit<TzStrict, '__type'>): FutureInstance<TaqError, TzStrict> => of(input);\n\n// TEMP: for interoperation with old protocol types during transition\nexport const schemas = {\n\trawSchema: tzSchema,\n\tschema: tzSchema.transform(val => val as TzStrict),\n};\nexport const rawSchema = schemas.rawSchema;\nexport const internalSchema = tzSchema;\n\nexport type t = TzStrict;\n        "],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,sBAAmG;AACnG,qBAAgD;AAChD,iBAAyB;AAGzB,uBAAyB;AAIlB,IAAM,OAAO,CAAC,UAA6B;AACjD,MAAI;AACH,WAAO,0BAAS,MAAM,KAAK;AAAA,EAC5B,SACO,UAAP;AACC,QAAI,oBAAoB,qBAAU;AACjC,YAAM,OAAiB,SAAS,OAAO;AAAA,QACtC,CAAC,QAAQ,UAAU;AAClB,gBAAM,OAAO,MAAM,KAAK,KAAK,UAAK;AAClC,gBAAM,MAAM,OAAO,OAAO,MAAM;AAChC,iBAAO,CAAC,GAAG,QAAQ,GAAG;AAAA,QACvB;AAAA,QACA,CAAC,gBAAgB;AAAA,MAClB;AACA,YAAM,gBAAgB,KAAK,KAAK,IAAI,IAAI;AACxC,gBAAM,4BAAW,UAAU,aAAa;AAAA,IACzC;AACA,cAAM,mCAAkB,UAAU,2CAA2C;AAAA,EAC9E;AAED;AAEO,IAAM,SAAS,CAAC,UAAwB,KAAK,KAAK;AAElD,IAAM,KAAK,CAAC,UAAuD;AACzE,MAAI;AACH,eAAO,wBAAQ,KAAK,KAAK,CAAC;AAAA,EAC3B,SACO,KAAP;AACC,eAAO,uBAAO,GAAG;AAAA,EAClB;AACD;AAEO,IAAM,OAAO,CAAC,UAAwE,GAAG,KAAK;AAG9F,IAAM,UAAU;AAAA,EACtB,WAAW;AAAA,EACX,QAAQ,0BAAS,UAAU,SAAO,GAAe;AAClD;AACO,IAAM,YAAY,QAAQ;AAC1B,IAAM,iBAAiB;","names":[]}

package/out/types/Tz.mjs

@@ -0,0 +1,49 @@
+// out/types/Tz.ts
+import { toParseErr, toParseUnknownErr } from "@taqueria/protocol/TaqError";
+import { resolve, reject } from "fluture";
+import { ZodError } from "zod";
+import { tzSchema } from "@taqueria/protocol/out/types-zod";
+var from = (input) => {
+  try {
+    return tzSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path = issue.path.join(" \u2192 ");
+          const msg = path + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Tz is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Tz.");
+  }
+};
+var create = (input) => from(input);
+var of = (input) => {
+  try {
+    return resolve(from(input));
+  } catch (err) {
+    return reject(err);
+  }
+};
+var make = (input) => of(input);
+var schemas = {
+  rawSchema: tzSchema,
+  schema: tzSchema.transform((val) => val)
+};
+var rawSchema = schemas.rawSchema;
+var internalSchema = tzSchema;
+export {
+  create,
+  from,
+  internalSchema,
+  make,
+  of,
+  rawSchema,
+  schemas
+};
+//# sourceMappingURL=Tz.mjs.map

package/out/types/Tz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Tz.ts"],"sourcesContent":["// Generated file: Do not edit \n// generated from @taqueria-protocol-types\n    \nimport { TaqError, toFutureParseErr, toFutureParseUnknownErr, toParseErr, toParseUnknownErr } from '@taqueria/protocol/TaqError';\nimport { FutureInstance, resolve, reject } from 'fluture';\nimport { ZodError } from 'zod';\nimport { Tz } from '@taqueria/protocol/types';\nimport { Tz as TzStrict } from '@taqueria/protocol/out/types-strict';\nimport { tzSchema } from '@taqueria/protocol/out/types-zod';\n\nexport type { TzStrict as Tz };\n\nexport const from = (input: unknown): TzStrict => {\n\ttry {\n\t\treturn tzSchema.parse(input) as TzStrict;\n\t}\n\tcatch (previous: unknown) {\n\t\tif (previous instanceof ZodError) {\n\t\t\tconst msgs: string[] = previous.errors.reduce(\n\t\t\t\t(retval, issue) => {\n\t\t\t\t\tconst path = issue.path.join(' → ');\n\t\t\t\t\tconst msg = path + ': ' + issue.message;\n\t\t\t\t\treturn [...retval, msg];\n\t\t\t\t},\n\t\t\t\t[\"Tz is invalid:\"],\n\t\t\t);\n\t\t\tconst validationErr = msgs.join('\\n') + '\\n';\n\t\t\tthrow toParseErr(previous, validationErr);\n\t\t}\n\t\tthrow toParseUnknownErr(previous, \"There was a problem trying to parse a Tz.\")\n\t}\n    \n};\n\nexport const create = (input: Tz): TzStrict => from(input);\n\nexport const of = (input: unknown): FutureInstance<TaqError, TzStrict> => {\n\ttry {\n\t\treturn resolve(from(input))\n\t}\n\tcatch (err){\n\t\treturn reject(err) as FutureInstance<TaqError, never>\n\t}\n};\n\nexport const make = (input: Omit<TzStrict, '__type'>): FutureInstance<TaqError, TzStrict> => of(input);\n\n// TEMP: for interoperation with old protocol types during transition\nexport const schemas = {\n\trawSchema: tzSchema,\n\tschema: tzSchema.transform(val => val as TzStrict),\n};\nexport const rawSchema = schemas.rawSchema;\nexport const internalSchema = tzSchema;\n\nexport type t = TzStrict;\n        "],"mappings":";AAGA,SAA8D,YAAY,yBAAyB;AACnG,SAAyB,SAAS,cAAc;AAChD,SAAS,gBAAgB;AAGzB,SAAS,gBAAgB;AAIlB,IAAM,OAAO,CAAC,UAA6B;AACjD,MAAI;AACH,WAAO,SAAS,MAAM,KAAK;AAAA,EAC5B,SACO,UAAP;AACC,QAAI,oBAAoB,UAAU;AACjC,YAAM,OAAiB,SAAS,OAAO;AAAA,QACtC,CAAC,QAAQ,UAAU;AAClB,gBAAM,OAAO,MAAM,KAAK,KAAK,UAAK;AAClC,gBAAM,MAAM,OAAO,OAAO,MAAM;AAChC,iBAAO,CAAC,GAAG,QAAQ,GAAG;AAAA,QACvB;AAAA,QACA,CAAC,gBAAgB;AAAA,MAClB;AACA,YAAM,gBAAgB,KAAK,KAAK,IAAI,IAAI;AACxC,YAAM,WAAW,UAAU,aAAa;AAAA,IACzC;AACA,UAAM,kBAAkB,UAAU,2CAA2C;AAAA,EAC9E;AAED;AAEO,IAAM,SAAS,CAAC,UAAwB,KAAK,KAAK;AAElD,IAAM,KAAK,CAAC,UAAuD;AACzE,MAAI;AACH,WAAO,QAAQ,KAAK,KAAK,CAAC;AAAA,EAC3B,SACO,KAAP;AACC,WAAO,OAAO,GAAG;AAAA,EAClB;AACD;AAEO,IAAM,OAAO,CAAC,UAAwE,GAAG,KAAK;AAG9F,IAAM,UAAU;AAAA,EACtB,WAAW;AAAA,EACX,QAAQ,SAAS,UAAU,SAAO,GAAe;AAClD;AACO,IAAM,YAAY,QAAQ;AAC1B,IAAM,iBAAiB;","names":[]}

package/out/types/TzKtConfig.d.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// out/types/TzKtConfig.d.ts
+var TzKtConfig_d_exports = {};
+module.exports = __toCommonJS(TzKtConfig_d_exports);
+//# sourceMappingURL=TzKtConfig.d.js.map

package/out/types/TzKtConfig.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["TzKtConfig.ts"],"sourcesContent":["// Generated file: Do not edit \n// generated from @taqueria-protocol-types\n    \nimport { TaqError, toFutureParseErr, toFutureParseUnknownErr, toParseErr, toParseUnknownErr } from '@taqueria/protocol/TaqError';\nimport { FutureInstance, resolve, reject } from 'fluture';\nimport { ZodError } from 'zod';\nimport { TzKtConfig } from '@taqueria/protocol/types';\nimport { TzKtConfig as TzKtConfigStrict } from '@taqueria/protocol/out/types-strict';\nimport { tzKtConfigSchema } from '@taqueria/protocol/out/types-zod';\n\nexport type { TzKtConfigStrict as TzKtConfig };\n\nexport const from = (input: unknown): TzKtConfigStrict => {\n\ttry {\n\t\treturn tzKtConfigSchema.parse(input) as TzKtConfigStrict;\n\t}\n\tcatch (previous: unknown) {\n\t\tif (previous instanceof ZodError) {\n\t\t\tconst msgs: string[] = previous.errors.reduce(\n\t\t\t\t(retval, issue) => {\n\t\t\t\t\tconst path = issue.path.join(' → ');\n\t\t\t\t\tconst msg = path + ': ' + issue.message;\n\t\t\t\t\treturn [...retval, msg];\n\t\t\t\t},\n\t\t\t\t[\"TzKtConfig is invalid:\"],\n\t\t\t);\n\t\t\tconst validationErr = msgs.join('\\n') + '\\n';\n\t\t\tthrow toParseErr(previous, validationErr);\n\t\t}\n\t\tthrow toParseUnknownErr(previous, \"There was a problem trying to parse a TzKtConfig.\")\n\t}\n    \n};\n\nexport const create = (input: TzKtConfig): TzKtConfigStrict => from(input);\n\nexport const of = (input: unknown): FutureInstance<TaqError, TzKtConfigStrict> => {\n\ttry {\n\t\treturn resolve(from(input))\n\t}\n\tcatch (err){\n\t\treturn reject(err) as FutureInstance<TaqError, never>\n\t}\n};\n\nexport const make = (input: Omit<TzKtConfigStrict, '__type'>): FutureInstance<TaqError, TzKtConfigStrict> => of(input);\n\n// TEMP: for interoperation with old protocol types during transition\nexport const schemas = {\n\trawSchema: tzKtConfigSchema,\n\tschema: tzKtConfigSchema.transform(val => val as TzKtConfigStrict),\n};\nexport const rawSchema = schemas.rawSchema;\nexport const internalSchema = tzKtConfigSchema;\n\nexport type t = TzKtConfigStrict;\n        "],"mappings":";;;;;;;;;;;;;;;;AAGA;;","names":[]}

package/out/types/TzKtConfig.d.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=TzKtConfig.d.mjs.map

package/out/types/TzKtConfig.d.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}