@taqueria/protocol 0.16.0 → 0.19.2

package/PluginInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginInfo.d.ts","sourceRoot":"","sources":["PluginInfo.ts"],"names":[],"mappings":"AACA,OAAmB,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAK9D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBpB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBC,CAAC;AAO7B,eAAO,MAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK7B,CAAC;AAEH,oBAAY,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;AACjE,oBAAY,CAAC,GAAG,UAAU,CAAC;AAC3B,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAY,CAAC"}

package/PluginInfo.js

@@ -0,0 +1,113 @@
+"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);
+
+// PluginInfo.ts
+var PluginInfo_exports = {};
+__export(PluginInfo_exports, {
+  create: () => create,
+  factory: () => factory,
+  internalSchema: () => internalSchema,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema3,
+  schemas: () => schemas6
+});
+module.exports = __toCommonJS(PluginInfo_exports);
+var Alias = __toESM(require("@taqueria/protocol/Alias"));
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var ParsedOperation = __toESM(require("@taqueria/protocol/ParsedOperation"));
+var ParsedTemplate = __toESM(require("@taqueria/protocol/ParsedTemplate"));
+var Task = __toESM(require("@taqueria/protocol/Task"));
+var VersionNumber = __toESM(require("@taqueria/protocol/VersionNumber"));
+var import_zod = require("zod");
+var rawSchema3 = import_zod.z.object({
+  name: import_zod.z.string({ description: "Plugin Name" }).min(1),
+  version: VersionNumber.rawSchema.describe("Plugin Version #"),
+  schema: VersionNumber.rawSchema.describe("Plugin Schema Version #"),
+  alias: Alias.rawSchema.describe("Plugin Alias"),
+  tasks: import_zod.z.preprocess(
+    (val) => val ?? [],
+    import_zod.z.array(
+      Task.schemas.schema.describe("Plugin Task"),
+      { description: "Plugin Tasks" }
+    )
+  ).optional(),
+  operations: import_zod.z.preprocess(
+    (val) => val ?? [],
+    import_zod.z.array(
+      ParsedOperation.schemas.schema.describe("Plugin Operation"),
+      { description: "Plugin Operations" }
+    )
+  ).optional(),
+  templates: import_zod.z.preprocess(
+    (val) => val ?? [],
+    import_zod.z.array(
+      ParsedTemplate.schemas.schema.describe("Plugin Template")
+    )
+  ).optional()
+});
+var internalSchema = rawSchema3.extend({
+  version: VersionNumber.schemas.schema.describe("Plugin Version #"),
+  schema: VersionNumber.schemas.schema.describe("Plugin Schema Version #"),
+  alias: Alias.schemas.schema.describe("Plugin Alias"),
+  tasks: import_zod.z.preprocess(
+    (val) => val ?? [],
+    import_zod.z.array(
+      Task.schemas.schema.describe("Plugin Task"),
+      { description: "Plugin Tasks" }
+    )
+  ).optional(),
+  operations: import_zod.z.preprocess(
+    (val) => val ?? [],
+    import_zod.z.array(
+      ParsedOperation.schemas.schema.describe("Plugin Operation"),
+      { description: "Plugin Operations" }
+    )
+  ).optional(),
+  templates: import_zod.z.preprocess(
+    (val) => val ?? [],
+    import_zod.z.array(
+      ParsedTemplate.schemas.schema.describe("Plugin Template")
+    )
+  ).optional()
+}).describe("Plugin Schema");
+var { schemas: schemas6, factory } = (0, import_Base.default)({
+  rawSchema: rawSchema3,
+  internalSchema,
+  parseErrMsg: "The schema returned from the plugin is invalid",
+  unknownErrMsg: "Something went wrong parsing the schema from a plugin"
+});
+var { create, of, make } = factory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  factory,
+  internalSchema,
+  make,
+  of,
+  rawSchema,
+  schemas
+});
+//# sourceMappingURL=PluginInfo.js.map

package/PluginInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PluginInfo.ts"],"sourcesContent":["import * as Alias from '@taqueria/protocol/Alias';\nimport createType, { Flatten } from '@taqueria/protocol/Base';\nimport * as ParsedOperation from '@taqueria/protocol/ParsedOperation';\nimport * as ParsedTemplate from '@taqueria/protocol/ParsedTemplate';\nimport * as Task from '@taqueria/protocol/Task';\nimport * as VersionNumber from '@taqueria/protocol/VersionNumber';\nimport { z } from 'zod';\n\nexport const rawSchema = z.object({\n\tname: z.string({ description: 'Plugin Name' }).min(1),\n\tversion: VersionNumber.rawSchema.describe('Plugin Version #'),\n\tschema: VersionNumber.rawSchema.describe('Plugin Schema Version #'),\n\talias: Alias.rawSchema.describe('Plugin Alias'),\n\ttasks: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tTask.schemas.schema.describe('Plugin Task'),\n\t\t\t{ description: 'Plugin Tasks' },\n\t\t),\n\t).optional(),\n\toperations: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tParsedOperation.schemas.schema.describe('Plugin Operation'),\n\t\t\t{ description: 'Plugin Operations' },\n\t\t),\n\t).optional(),\n\ttemplates: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tParsedTemplate.schemas.schema.describe('Plugin Template'),\n\t\t),\n\t).optional(),\n});\n\nexport const internalSchema = rawSchema.extend({\n\tversion: VersionNumber.schemas.schema.describe('Plugin Version #'),\n\tschema: VersionNumber.schemas.schema.describe('Plugin Schema Version #'),\n\talias: Alias.schemas.schema.describe('Plugin Alias'),\n\ttasks: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tTask.schemas.schema.describe('Plugin Task'),\n\t\t\t{ description: 'Plugin Tasks' },\n\t\t),\n\t).optional(),\n\toperations: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tParsedOperation.schemas.schema.describe('Plugin Operation'),\n\t\t\t{ description: 'Plugin Operations' },\n\t\t),\n\t).optional(),\n\ttemplates: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tParsedTemplate.schemas.schema.describe('Plugin Template'),\n\t\t),\n\t).optional(),\n}).describe('Plugin Schema');\n\n// export const rawSchema = internalSchema;\n\ntype RawInput = z.infer<typeof rawSchema>;\ntype Input = Flatten<z.infer<typeof internalSchema>>;\n\nexport const { schemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: 'The schema returned from the plugin is invalid',\n\tunknownErrMsg: 'Something went wrong parsing the schema from a plugin',\n});\n\nexport type PluginInfo = Flatten<z.infer<typeof schemas.schema>>;\nexport type t = PluginInfo;\nexport const { create, of, make } = factory;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAAA;AAAA,EAAA,eAAAC;AAAA;AAAA;AAAA,YAAuB;AACvB,kBAAoC;AACpC,sBAAiC;AACjC,qBAAgC;AAChC,WAAsB;AACtB,oBAA+B;AAC/B,iBAAkB;AAEX,IAAMD,aAAY,aAAE,OAAO;AAAA,EACjC,MAAM,aAAE,OAAO,EAAE,aAAa,cAAc,CAAC,EAAE,IAAI,CAAC;AAAA,EACpD,SAAuB,wBAAU,SAAS,kBAAkB;AAAA,EAC5D,QAAsB,wBAAU,SAAS,yBAAyB;AAAA,EAClE,OAAa,gBAAU,SAAS,cAAc;AAAA,EAC9C,OAAO,aAAE;AAAA,IACR,SAAO,OAAO,CAAC;AAAA,IACf,aAAE;AAAA,MACI,aAAQ,OAAO,SAAS,aAAa;AAAA,MAC1C,EAAE,aAAa,eAAe;AAAA,IAC/B;AAAA,EACD,EAAE,SAAS;AAAA,EACX,YAAY,aAAE;AAAA,IACb,SAAO,OAAO,CAAC;AAAA,IACf,aAAE;AAAA,MACe,wBAAQ,OAAO,SAAS,kBAAkB;AAAA,MAC1D,EAAE,aAAa,oBAAoB;AAAA,IACpC;AAAA,EACD,EAAE,SAAS;AAAA,EACX,WAAW,aAAE;AAAA,IACZ,SAAO,OAAO,CAAC;AAAA,IACf,aAAE;AAAA,MACc,uBAAQ,OAAO,SAAS,iBAAiB;AAAA,IACzD;AAAA,EACD,EAAE,SAAS;AACZ,CAAC;AAEM,IAAM,iBAAiBA,WAAU,OAAO;AAAA,EAC9C,SAAuB,sBAAQ,OAAO,SAAS,kBAAkB;AAAA,EACjE,QAAsB,sBAAQ,OAAO,SAAS,yBAAyB;AAAA,EACvE,OAAa,cAAQ,OAAO,SAAS,cAAc;AAAA,EACnD,OAAO,aAAE;AAAA,IACR,SAAO,OAAO,CAAC;AAAA,IACf,aAAE;AAAA,MACI,aAAQ,OAAO,SAAS,aAAa;AAAA,MAC1C,EAAE,aAAa,eAAe;AAAA,IAC/B;AAAA,EACD,EAAE,SAAS;AAAA,EACX,YAAY,aAAE;AAAA,IACb,SAAO,OAAO,CAAC;AAAA,IACf,aAAE;AAAA,MACe,wBAAQ,OAAO,SAAS,kBAAkB;AAAA,MAC1D,EAAE,aAAa,oBAAoB;AAAA,IACpC;AAAA,EACD,EAAE,SAAS;AAAA,EACX,WAAW,aAAE;AAAA,IACZ,SAAO,OAAO,CAAC;AAAA,IACf,aAAE;AAAA,MACc,uBAAQ,OAAO,SAAS,iBAAiB;AAAA,IACzD;AAAA,EACD,EAAE,SAAS;AACZ,CAAC,EAAE,SAAS,eAAe;AAOpB,IAAM,EAAE,SAAAC,UAAS,QAAQ,QAAI,YAAAC,SAA4B;AAAA,EAC/D,WAAAF;AAAA,EACA;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;","names":["rawSchema","schemas","createType"]}

package/PluginInfo.mjs

@@ -0,0 +1,76 @@
+// PluginInfo.ts
+import * as Alias from "@taqueria/protocol/Alias";
+import createType from "@taqueria/protocol/Base";
+import * as ParsedOperation from "@taqueria/protocol/ParsedOperation";
+import * as ParsedTemplate from "@taqueria/protocol/ParsedTemplate";
+import * as Task from "@taqueria/protocol/Task";
+import * as VersionNumber from "@taqueria/protocol/VersionNumber";
+import { z } from "zod";
+var rawSchema3 = z.object({
+  name: z.string({ description: "Plugin Name" }).min(1),
+  version: VersionNumber.rawSchema.describe("Plugin Version #"),
+  schema: VersionNumber.rawSchema.describe("Plugin Schema Version #"),
+  alias: Alias.rawSchema.describe("Plugin Alias"),
+  tasks: z.preprocess(
+    (val) => val ?? [],
+    z.array(
+      Task.schemas.schema.describe("Plugin Task"),
+      { description: "Plugin Tasks" }
+    )
+  ).optional(),
+  operations: z.preprocess(
+    (val) => val ?? [],
+    z.array(
+      ParsedOperation.schemas.schema.describe("Plugin Operation"),
+      { description: "Plugin Operations" }
+    )
+  ).optional(),
+  templates: z.preprocess(
+    (val) => val ?? [],
+    z.array(
+      ParsedTemplate.schemas.schema.describe("Plugin Template")
+    )
+  ).optional()
+});
+var internalSchema = rawSchema3.extend({
+  version: VersionNumber.schemas.schema.describe("Plugin Version #"),
+  schema: VersionNumber.schemas.schema.describe("Plugin Schema Version #"),
+  alias: Alias.schemas.schema.describe("Plugin Alias"),
+  tasks: z.preprocess(
+    (val) => val ?? [],
+    z.array(
+      Task.schemas.schema.describe("Plugin Task"),
+      { description: "Plugin Tasks" }
+    )
+  ).optional(),
+  operations: z.preprocess(
+    (val) => val ?? [],
+    z.array(
+      ParsedOperation.schemas.schema.describe("Plugin Operation"),
+      { description: "Plugin Operations" }
+    )
+  ).optional(),
+  templates: z.preprocess(
+    (val) => val ?? [],
+    z.array(
+      ParsedTemplate.schemas.schema.describe("Plugin Template")
+    )
+  ).optional()
+}).describe("Plugin Schema");
+var { schemas: schemas6, factory } = createType({
+  rawSchema: rawSchema3,
+  internalSchema,
+  parseErrMsg: "The schema returned from the plugin is invalid",
+  unknownErrMsg: "Something went wrong parsing the schema from a plugin"
+});
+var { create, of, make } = factory;
+export {
+  create,
+  factory,
+  internalSchema,
+  make,
+  of,
+  rawSchema3 as rawSchema,
+  schemas6 as schemas
+};
+//# sourceMappingURL=PluginInfo.mjs.map

package/PluginInfo.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PluginInfo.ts"],"sourcesContent":["import * as Alias from '@taqueria/protocol/Alias';\nimport createType, { Flatten } from '@taqueria/protocol/Base';\nimport * as ParsedOperation from '@taqueria/protocol/ParsedOperation';\nimport * as ParsedTemplate from '@taqueria/protocol/ParsedTemplate';\nimport * as Task from '@taqueria/protocol/Task';\nimport * as VersionNumber from '@taqueria/protocol/VersionNumber';\nimport { z } from 'zod';\n\nexport const rawSchema = z.object({\n\tname: z.string({ description: 'Plugin Name' }).min(1),\n\tversion: VersionNumber.rawSchema.describe('Plugin Version #'),\n\tschema: VersionNumber.rawSchema.describe('Plugin Schema Version #'),\n\talias: Alias.rawSchema.describe('Plugin Alias'),\n\ttasks: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tTask.schemas.schema.describe('Plugin Task'),\n\t\t\t{ description: 'Plugin Tasks' },\n\t\t),\n\t).optional(),\n\toperations: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tParsedOperation.schemas.schema.describe('Plugin Operation'),\n\t\t\t{ description: 'Plugin Operations' },\n\t\t),\n\t).optional(),\n\ttemplates: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tParsedTemplate.schemas.schema.describe('Plugin Template'),\n\t\t),\n\t).optional(),\n});\n\nexport const internalSchema = rawSchema.extend({\n\tversion: VersionNumber.schemas.schema.describe('Plugin Version #'),\n\tschema: VersionNumber.schemas.schema.describe('Plugin Schema Version #'),\n\talias: Alias.schemas.schema.describe('Plugin Alias'),\n\ttasks: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tTask.schemas.schema.describe('Plugin Task'),\n\t\t\t{ description: 'Plugin Tasks' },\n\t\t),\n\t).optional(),\n\toperations: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tParsedOperation.schemas.schema.describe('Plugin Operation'),\n\t\t\t{ description: 'Plugin Operations' },\n\t\t),\n\t).optional(),\n\ttemplates: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(\n\t\t\tParsedTemplate.schemas.schema.describe('Plugin Template'),\n\t\t),\n\t).optional(),\n}).describe('Plugin Schema');\n\n// export const rawSchema = internalSchema;\n\ntype RawInput = z.infer<typeof rawSchema>;\ntype Input = Flatten<z.infer<typeof internalSchema>>;\n\nexport const { schemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: 'The schema returned from the plugin is invalid',\n\tunknownErrMsg: 'Something went wrong parsing the schema from a plugin',\n});\n\nexport type PluginInfo = Flatten<z.infer<typeof schemas.schema>>;\nexport type t = PluginInfo;\nexport const { create, of, make } = factory;\n"],"mappings":";AAAA,YAAY,WAAW;AACvB,OAAO,gBAA6B;AACpC,YAAY,qBAAqB;AACjC,YAAY,oBAAoB;AAChC,YAAY,UAAU;AACtB,YAAY,mBAAmB;AAC/B,SAAS,SAAS;AAEX,IAAMA,aAAY,EAAE,OAAO;AAAA,EACjC,MAAM,EAAE,OAAO,EAAE,aAAa,cAAc,CAAC,EAAE,IAAI,CAAC;AAAA,EACpD,SAAuB,wBAAU,SAAS,kBAAkB;AAAA,EAC5D,QAAsB,wBAAU,SAAS,yBAAyB;AAAA,EAClE,OAAa,gBAAU,SAAS,cAAc;AAAA,EAC9C,OAAO,EAAE;AAAA,IACR,SAAO,OAAO,CAAC;AAAA,IACf,EAAE;AAAA,MACI,aAAQ,OAAO,SAAS,aAAa;AAAA,MAC1C,EAAE,aAAa,eAAe;AAAA,IAC/B;AAAA,EACD,EAAE,SAAS;AAAA,EACX,YAAY,EAAE;AAAA,IACb,SAAO,OAAO,CAAC;AAAA,IACf,EAAE;AAAA,MACe,wBAAQ,OAAO,SAAS,kBAAkB;AAAA,MAC1D,EAAE,aAAa,oBAAoB;AAAA,IACpC;AAAA,EACD,EAAE,SAAS;AAAA,EACX,WAAW,EAAE;AAAA,IACZ,SAAO,OAAO,CAAC;AAAA,IACf,EAAE;AAAA,MACc,uBAAQ,OAAO,SAAS,iBAAiB;AAAA,IACzD;AAAA,EACD,EAAE,SAAS;AACZ,CAAC;AAEM,IAAM,iBAAiBA,WAAU,OAAO;AAAA,EAC9C,SAAuB,sBAAQ,OAAO,SAAS,kBAAkB;AAAA,EACjE,QAAsB,sBAAQ,OAAO,SAAS,yBAAyB;AAAA,EACvE,OAAa,cAAQ,OAAO,SAAS,cAAc;AAAA,EACnD,OAAO,EAAE;AAAA,IACR,SAAO,OAAO,CAAC;AAAA,IACf,EAAE;AAAA,MACI,aAAQ,OAAO,SAAS,aAAa;AAAA,MAC1C,EAAE,aAAa,eAAe;AAAA,IAC/B;AAAA,EACD,EAAE,SAAS;AAAA,EACX,YAAY,EAAE;AAAA,IACb,SAAO,OAAO,CAAC;AAAA,IACf,EAAE;AAAA,MACe,wBAAQ,OAAO,SAAS,kBAAkB;AAAA,MAC1D,EAAE,aAAa,oBAAoB;AAAA,IACpC;AAAA,EACD,EAAE,SAAS;AAAA,EACX,WAAW,EAAE;AAAA,IACZ,SAAO,OAAO,CAAC;AAAA,IACf,EAAE;AAAA,MACc,uBAAQ,OAAO,SAAS,iBAAiB;AAAA,IACzD;AAAA,EACD,EAAE,SAAS;AACZ,CAAC,EAAE,SAAS,eAAe;AAOpB,IAAM,EAAE,SAAAC,UAAS,QAAQ,IAAI,WAA4B;AAAA,EAC/D,WAAAD;AAAA,EACA;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;","names":["rawSchema","schemas"]}

package/PluginJsonResponse.d.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+export declare const rawSchema: z.ZodObject<{
+    data: z.ZodOptional<z.ZodUnknown>;
+    render: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"none">, z.ZodLiteral<"table">, z.ZodLiteral<"string">]>>;
+}, "strip", z.ZodTypeAny, {
+    data?: unknown;
+    render?: "string" | "none" | "table" | undefined;
+}, {
+    data?: unknown;
+    render?: "string" | "none" | "table" | undefined;
+}>;
+export declare const pluginJsonResponse: {
+    schemas: {
+        rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+        internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+        schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
+            data?: unknown;
+            render?: "string" | "none" | "table" | undefined;
+        } & {
+            readonly __kind: any;
+        }, any>;
+    };
+    factory: {
+        make: (input: {
+            data?: unknown;
+            render?: "string" | "none" | "table" | undefined;
+        }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+            data?: unknown;
+            render?: "string" | "none" | "table" | undefined;
+        } & {
+            readonly __kind: any;
+        }>;
+        of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+            data?: unknown;
+            render?: "string" | "none" | "table" | undefined;
+        } & {
+            readonly __kind: any;
+        }>;
+        create: (input: {
+            data?: unknown;
+            render?: "string" | "none" | "table" | undefined;
+        }) => {
+            data?: unknown;
+            render?: "string" | "none" | "table" | undefined;
+        } & {
+            readonly __kind: any;
+        };
+        from: (input: unknown) => {
+            data?: unknown;
+            render?: "string" | "none" | "table" | undefined;
+        } & {
+            readonly __kind: any;
+        };
+    };
+};
+export declare type PluginJsonResponse = z.infer<typeof pluginJsonResponse.schemas.schema>;
+export declare type t = PluginJsonResponse;
+export declare const schemas: {
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
+        data?: unknown;
+        render?: "string" | "none" | "table" | undefined;
+    } & {
+        readonly __kind: any;
+    }, any>;
+}, factory: {
+    make: (input: {
+        data?: unknown;
+        render?: "string" | "none" | "table" | undefined;
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        data?: unknown;
+        render?: "string" | "none" | "table" | undefined;
+    } & {
+        readonly __kind: any;
+    }>;
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        data?: unknown;
+        render?: "string" | "none" | "table" | undefined;
+    } & {
+        readonly __kind: any;
+    }>;
+    create: (input: {
+        data?: unknown;
+        render?: "string" | "none" | "table" | undefined;
+    }) => {
+        data?: unknown;
+        render?: "string" | "none" | "table" | undefined;
+    } & {
+        readonly __kind: any;
+    };
+    from: (input: unknown) => {
+        data?: unknown;
+        render?: "string" | "none" | "table" | undefined;
+    } & {
+        readonly __kind: any;
+    };
+};
+//# sourceMappingURL=PluginJsonResponse.d.ts.map

package/PluginJsonResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginJsonResponse.d.ts","sourceRoot":"","sources":["PluginJsonResponse.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;EAOpB,CAAC;AAIH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK7B,CAAC;AAEH,oBAAY,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;AAEnF,oBAAY,CAAC,GAAG,kBAAkB,CAAC;AAEnC,eAAO,MAAQ,OAAO;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAuB,CAAC"}

package/PluginJsonResponse.js

@@ -0,0 +1,59 @@
+"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);
+
+// PluginJsonResponse.ts
+var PluginJsonResponse_exports = {};
+__export(PluginJsonResponse_exports, {
+  factory: () => factory,
+  pluginJsonResponse: () => pluginJsonResponse,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas
+});
+module.exports = __toCommonJS(PluginJsonResponse_exports);
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var import_zod = require("zod");
+var rawSchema = import_zod.z.object({
+  data: import_zod.z.unknown().optional(),
+  render: import_zod.z.union([
+    import_zod.z.literal("none"),
+    import_zod.z.literal("table"),
+    import_zod.z.literal("string")
+  ]).optional()
+});
+var pluginJsonResponse = (0, import_Base.default)({
+  rawSchema,
+  internalSchema: rawSchema,
+  parseErrMsg: (value) => `The following JSON response is invalid: ${value}`,
+  unknownErrMsg: "Something went wrong trying to parse the template"
+});
+var { schemas, factory } = pluginJsonResponse;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  factory,
+  pluginJsonResponse,
+  rawSchema,
+  schemas
+});
+//# sourceMappingURL=PluginJsonResponse.js.map

package/PluginJsonResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PluginJsonResponse.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nexport const rawSchema = z.object({\n\tdata: z.unknown().optional(),\n\trender: z.union([\n\t\tz.literal('none'),\n\t\tz.literal('table'),\n\t\tz.literal('string'),\n\t]).optional(),\n});\n\ntype RawPluginJsonResponseInput = z.infer<typeof rawSchema>;\n\nexport const pluginJsonResponse = createType<RawPluginJsonResponseInput, RawPluginJsonResponseInput>({\n\trawSchema: rawSchema,\n\tinternalSchema: rawSchema,\n\tparseErrMsg: (value: unknown) => `The following JSON response is invalid: ${value}`,\n\tunknownErrMsg: 'Something went wrong trying to parse the template',\n});\n\nexport type PluginJsonResponse = z.infer<typeof pluginJsonResponse.schemas.schema>;\n\nexport type t = PluginJsonResponse;\n\nexport const { schemas, factory } = pluginJsonResponse;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAuB;AACvB,iBAAkB;AAEX,IAAM,YAAY,aAAE,OAAO;AAAA,EACjC,MAAM,aAAE,QAAQ,EAAE,SAAS;AAAA,EAC3B,QAAQ,aAAE,MAAM;AAAA,IACf,aAAE,QAAQ,MAAM;AAAA,IAChB,aAAE,QAAQ,OAAO;AAAA,IACjB,aAAE,QAAQ,QAAQ;AAAA,EACnB,CAAC,EAAE,SAAS;AACb,CAAC;AAIM,IAAM,yBAAqB,YAAAA,SAAmE;AAAA,EACpG;AAAA,EACA,gBAAgB;AAAA,EAChB,aAAa,CAAC,UAAmB,2CAA2C;AAAA,EAC5E,eAAe;AAChB,CAAC;AAMM,IAAM,EAAE,SAAS,QAAQ,IAAI;","names":["createType"]}

package/PluginJsonResponse.mjs

@@ -0,0 +1,25 @@
+// PluginJsonResponse.ts
+import createType from "@taqueria/protocol/Base";
+import { z } from "zod";
+var rawSchema = z.object({
+  data: z.unknown().optional(),
+  render: z.union([
+    z.literal("none"),
+    z.literal("table"),
+    z.literal("string")
+  ]).optional()
+});
+var pluginJsonResponse = createType({
+  rawSchema,
+  internalSchema: rawSchema,
+  parseErrMsg: (value) => `The following JSON response is invalid: ${value}`,
+  unknownErrMsg: "Something went wrong trying to parse the template"
+});
+var { schemas, factory } = pluginJsonResponse;
+export {
+  factory,
+  pluginJsonResponse,
+  rawSchema,
+  schemas
+};
+//# sourceMappingURL=PluginJsonResponse.mjs.map

package/PluginJsonResponse.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PluginJsonResponse.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nexport const rawSchema = z.object({\n\tdata: z.unknown().optional(),\n\trender: z.union([\n\t\tz.literal('none'),\n\t\tz.literal('table'),\n\t\tz.literal('string'),\n\t]).optional(),\n});\n\ntype RawPluginJsonResponseInput = z.infer<typeof rawSchema>;\n\nexport const pluginJsonResponse = createType<RawPluginJsonResponseInput, RawPluginJsonResponseInput>({\n\trawSchema: rawSchema,\n\tinternalSchema: rawSchema,\n\tparseErrMsg: (value: unknown) => `The following JSON response is invalid: ${value}`,\n\tunknownErrMsg: 'Something went wrong trying to parse the template',\n});\n\nexport type PluginJsonResponse = z.infer<typeof pluginJsonResponse.schemas.schema>;\n\nexport type t = PluginJsonResponse;\n\nexport const { schemas, factory } = pluginJsonResponse;\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,SAAS,SAAS;AAEX,IAAM,YAAY,EAAE,OAAO;AAAA,EACjC,MAAM,EAAE,QAAQ,EAAE,SAAS;AAAA,EAC3B,QAAQ,EAAE,MAAM;AAAA,IACf,EAAE,QAAQ,MAAM;AAAA,IAChB,EAAE,QAAQ,OAAO;AAAA,IACjB,EAAE,QAAQ,QAAQ;AAAA,EACnB,CAAC,EAAE,SAAS;AACb,CAAC;AAIM,IAAM,qBAAqB,WAAmE;AAAA,EACpG;AAAA,EACA,gBAAgB;AAAA,EAChB,aAAa,CAAC,UAAmB,2CAA2C;AAAA,EAC5E,eAAe;AAChB,CAAC;AAMM,IAAM,EAAE,SAAS,QAAQ,IAAI;","names":[]}

package/PluginProxyResponse.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const rawSchema: z.ZodUnion<[z.ZodType<any, z.ZodTypeDef, any>, z.ZodVoid]>;
+export declare const schemas: {
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, any, any>;
+}, factory: {
+    make: (input: any) => import("fluture").FutureInstance<import("./TaqError").TaqError, any>;
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, any>;
+    create: (input: any) => any;
+    from: (input: unknown) => any;
+};
+export declare type PluginProxyResponse = z.infer<typeof schemas.schema>;
+export declare type t = PluginProxyResponse;
+export declare const of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, any>, make: (input: any) => import("fluture").FutureInstance<import("./TaqError").TaqError, any>, create: (input: any) => any;
+//# sourceMappingURL=PluginProxyResponse.d.ts.map

package/PluginProxyResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginProxyResponse.d.ts","sourceRoot":"","sources":["PluginProxyResponse.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,SAAS,4DAAiB,CAAC;AAIxC,eAAO,MAAQ,OAAO;;;;GAAE,OAAO;;;;;CAK7B,CAAC;AAEH,oBAAY,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC;AACjE,oBAAY,CAAC,GAAG,mBAAmB,CAAC;AAEpC,eAAO,MAAQ,EAAE,4FAAE,IAAI,wFAAE,MAAM,qBAAY,CAAC"}

package/PluginProxyResponse.js

@@ -0,0 +1,61 @@
+"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);
+
+// PluginProxyResponse.ts
+var PluginProxyResponse_exports = {};
+__export(PluginProxyResponse_exports, {
+  create: () => create,
+  factory: () => factory,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas2
+});
+module.exports = __toCommonJS(PluginProxyResponse_exports);
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var PluginJsonResponse = __toESM(require("@taqueria/protocol/PluginJsonResponse"));
+var import_zod = require("zod");
+var internalSchema = import_zod.z.union([
+  PluginJsonResponse.schemas.internalSchema,
+  import_zod.z.void()
+]);
+var rawSchema = internalSchema;
+var { schemas: schemas2, factory } = (0, import_Base.default)({
+  rawSchema,
+  internalSchema,
+  parseErrMsg: "The response from the proxy request is invalid",
+  unknownErrMsg: "Something went wrong parsing the proxy response from the plugin"
+});
+var { of, make, create } = factory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  factory,
+  make,
+  of,
+  rawSchema,
+  schemas
+});
+//# sourceMappingURL=PluginProxyResponse.js.map

package/PluginProxyResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PluginProxyResponse.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as PluginJsonResponse from '@taqueria/protocol/PluginJsonResponse';\nimport { z } from 'zod';\n\nconst internalSchema = z.union([\n\tPluginJsonResponse.schemas.internalSchema,\n\tz.void(),\n]);\n\nexport const rawSchema = internalSchema;\n\ntype Input = z.infer<typeof internalSchema>;\n\nexport const { schemas, factory } = createType<Input, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: 'The response from the proxy request is invalid',\n\tunknownErrMsg: 'Something went wrong parsing the proxy response from the plugin',\n});\n\nexport type PluginProxyResponse = z.infer<typeof schemas.schema>;\nexport type t = PluginProxyResponse;\n\nexport const { of, make, create } = factory;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAAA;AAAA;AAAA;AAAA,kBAAuB;AACvB,yBAAoC;AACpC,iBAAkB;AAElB,IAAM,iBAAiB,aAAE,MAAM;AAAA,EACX,2BAAQ;AAAA,EAC3B,aAAE,KAAK;AACR,CAAC;AAEM,IAAM,YAAY;AAIlB,IAAM,EAAE,SAAAA,UAAS,QAAQ,QAAI,YAAAC,SAAyB;AAAA,EAC5D;AAAA,EACA;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAKM,IAAM,EAAE,IAAI,MAAM,OAAO,IAAI;","names":["schemas","createType"]}

package/PluginProxyResponse.mjs

@@ -0,0 +1,25 @@
+// PluginProxyResponse.ts
+import createType from "@taqueria/protocol/Base";
+import * as PluginJsonResponse from "@taqueria/protocol/PluginJsonResponse";
+import { z } from "zod";
+var internalSchema = z.union([
+  PluginJsonResponse.schemas.internalSchema,
+  z.void()
+]);
+var rawSchema = internalSchema;
+var { schemas: schemas2, factory } = createType({
+  rawSchema,
+  internalSchema,
+  parseErrMsg: "The response from the proxy request is invalid",
+  unknownErrMsg: "Something went wrong parsing the proxy response from the plugin"
+});
+var { of, make, create } = factory;
+export {
+  create,
+  factory,
+  make,
+  of,
+  rawSchema,
+  schemas2 as schemas
+};
+//# sourceMappingURL=PluginProxyResponse.mjs.map

package/PluginProxyResponse.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PluginProxyResponse.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as PluginJsonResponse from '@taqueria/protocol/PluginJsonResponse';\nimport { z } from 'zod';\n\nconst internalSchema = z.union([\n\tPluginJsonResponse.schemas.internalSchema,\n\tz.void(),\n]);\n\nexport const rawSchema = internalSchema;\n\ntype Input = z.infer<typeof internalSchema>;\n\nexport const { schemas, factory } = createType<Input, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: 'The response from the proxy request is invalid',\n\tunknownErrMsg: 'Something went wrong parsing the proxy response from the plugin',\n});\n\nexport type PluginProxyResponse = z.infer<typeof schemas.schema>;\nexport type t = PluginProxyResponse;\n\nexport const { of, make, create } = factory;\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,YAAY,wBAAwB;AACpC,SAAS,SAAS;AAElB,IAAM,iBAAiB,EAAE,MAAM;AAAA,EACX,2BAAQ;AAAA,EAC3B,EAAE,KAAK;AACR,CAAC;AAEM,IAAM,YAAY;AAIlB,IAAM,EAAE,SAAAA,UAAS,QAAQ,IAAI,WAAyB;AAAA,EAC5D;AAAA,EACA;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAKM,IAAM,EAAE,IAAI,MAAM,OAAO,IAAI;","names":["schemas"]}

package/PluginResponseEncoding.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const rawSchema: z.ZodEffects<z.ZodOptional<z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"json">, z.ZodLiteral<"application/json">, z.ZodLiteral<"none">]>>>, "none" | "json" | "application/json" | undefined, unknown>;
+export declare const schemas: {
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, ("none" | "json" | "application/json" | undefined) & {
+        readonly __kind: any;
+    }, any>;
+}, factory: {
+    make: (input: "none" | "json" | "application/json" | undefined) => import("fluture").FutureInstance<import("./TaqError").TaqError, ("none" | "json" | "application/json" | undefined) & {
+        readonly __kind: any;
+    }>;
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, ("none" | "json" | "application/json" | undefined) & {
+        readonly __kind: any;
+    }>;
+    create: (input: "none" | "json" | "application/json" | undefined) => ("none" | "json" | "application/json" | undefined) & {
+        readonly __kind: any;
+    };
+    from: (input: unknown) => ("none" | "json" | "application/json" | undefined) & {
+        readonly __kind: any;
+    };
+};
+export declare type PluginResponseEncoding = z.infer<typeof schemas.schema>;
+export declare type t = PluginResponseEncoding;
+export declare const create: (input: "none" | "json" | "application/json" | undefined) => ("none" | "json" | "application/json" | undefined) & {
+    readonly __kind: any;
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, ("none" | "json" | "application/json" | undefined) & {
+    readonly __kind: any;
+}>, make: (input: "none" | "json" | "application/json" | undefined) => import("fluture").FutureInstance<import("./TaqError").TaqError, ("none" | "json" | "application/json" | undefined) & {
+    readonly __kind: any;
+}>;
+//# sourceMappingURL=PluginResponseEncoding.d.ts.map

package/PluginResponseEncoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginResponseEncoding.d.ts","sourceRoot":"","sources":["PluginResponseEncoding.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS,kMASrB,CAAC;AAIF,eAAO,MAAQ,OAAO;;;;;;GAAE,OAAO;;;;;;;;;;;;;CAK7B,CAAC;AAEH,oBAAY,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC;AACpE,oBAAY,CAAC,GAAG,sBAAsB,CAAC;AAEvC,eAAO,MAAQ,MAAM;;GAAE,EAAE;;IAAE,IAAI;;EAAY,CAAC"}

package/PluginResponseEncoding.js

@@ -0,0 +1,63 @@
+"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);
+
+// PluginResponseEncoding.ts
+var PluginResponseEncoding_exports = {};
+__export(PluginResponseEncoding_exports, {
+  create: () => create,
+  factory: () => factory,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas
+});
+module.exports = __toCommonJS(PluginResponseEncoding_exports);
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var import_zod = require("zod");
+var rawSchema = import_zod.z.preprocess(
+  (val) => val ?? "none",
+  import_zod.z.union([
+    import_zod.z.literal("json"),
+    import_zod.z.literal("application/json"),
+    import_zod.z.literal("none")
+  ]).default("none").optional()
+);
+var { schemas, factory } = (0, import_Base.default)({
+  rawSchema,
+  internalSchema: rawSchema,
+  parseErrMsg: (value) => `The following encoding is invalid: ${value}`,
+  unknownErrMsg: "Something went wrong trying to parse the encoding"
+});
+var { create, of, make } = factory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  factory,
+  make,
+  of,
+  rawSchema,
+  schemas
+});
+//# sourceMappingURL=PluginResponseEncoding.js.map

package/PluginResponseEncoding.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PluginResponseEncoding.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nexport const rawSchema = z.preprocess(\n\t(val: unknown) => val ?? 'none',\n\tz.union([\n\t\tz.literal('json'),\n\t\tz.literal('application/json'),\n\t\tz.literal('none'),\n\t])\n\t\t.default('none')\n\t\t.optional(),\n);\n\ntype RawInput = z.infer<typeof rawSchema>;\n\nexport const { schemas, factory } = createType<RawInput, RawInput>({\n\trawSchema,\n\tinternalSchema: rawSchema,\n\tparseErrMsg: (value: unknown) => `The following encoding is invalid: ${value}`,\n\tunknownErrMsg: 'Something went wrong trying to parse the encoding',\n});\n\nexport type PluginResponseEncoding = z.infer<typeof schemas.schema>;\nexport type t = PluginResponseEncoding;\n\nexport const { create, of, make } = factory;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAuB;AACvB,iBAAkB;AAEX,IAAM,YAAY,aAAE;AAAA,EAC1B,CAAC,QAAiB,OAAO;AAAA,EACzB,aAAE,MAAM;AAAA,IACP,aAAE,QAAQ,MAAM;AAAA,IAChB,aAAE,QAAQ,kBAAkB;AAAA,IAC5B,aAAE,QAAQ,MAAM;AAAA,EACjB,CAAC,EACC,QAAQ,MAAM,EACd,SAAS;AACZ;AAIO,IAAM,EAAE,SAAS,QAAQ,QAAI,YAAAA,SAA+B;AAAA,EAClE;AAAA,EACA,gBAAgB;AAAA,EAChB,aAAa,CAAC,UAAmB,sCAAsC;AAAA,EACvE,eAAe;AAChB,CAAC;AAKM,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;","names":["createType"]}