@taqueria/protocol 0.16.0 → 0.19.2

package/RequestArgs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestArgs.d.ts","sourceRoot":"","sources":["RequestArgs.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6BxB,eAAO,MAAiB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK/C,CAAC;AAEH,oBAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAClE,oBAAY,CAAC,GAAG,WAAW,CAAC;AAE5B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC;AAuBF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/RequestArgs.js

@@ -0,0 +1,136 @@
+"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, 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 __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);
+
+// RequestArgs.ts
+var RequestArgs_exports = {};
+__export(RequestArgs_exports, {
+  create: () => create,
+  createProxyRequestArgs: () => createProxyRequestArgs,
+  createProxyTemplateRequestArgs: () => createProxyTemplateRequestArgs,
+  factory: () => factory,
+  from: () => from,
+  generatedSchemas: () => generatedSchemas,
+  make: () => make,
+  makeProxyRequestArgs: () => makeProxyRequestArgs,
+  makeProxyTemplateRequestArgs: () => makeProxyTemplateRequestArgs,
+  of: () => of,
+  ofProxyRequestArgs: () => ofProxyRequestArgs,
+  ofProxyTemplateRequestArgs: () => ofProxyTemplateRequestArgs,
+  proxy: () => proxy,
+  proxyFactory: () => proxyFactory,
+  proxySchemas: () => proxySchemas,
+  proxyTemplate: () => proxyTemplate,
+  schemas: () => schemas2
+});
+module.exports = __toCommonJS(RequestArgs_exports);
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var LoadedConfig = __toESM(require("@taqueria/protocol/LoadedConfig"));
+var import_SanitizedArgs = require("@taqueria/protocol/SanitizedArgs");
+var import_zod = require("zod");
+var taqRunSchema = import_zod.z.union([
+  import_zod.z.literal("pluginInfo"),
+  import_zod.z.literal("proxy"),
+  import_zod.z.literal("checkRuntimeDependencies"),
+  import_zod.z.literal("installRuntimeDependencies"),
+  import_zod.z.literal("proxyTemplate")
+]);
+var rawSchema2 = import_SanitizedArgs.rawSchema.extend({
+  taqRun: taqRunSchema,
+  config: import_zod.z.preprocess(
+    (val) => typeof val === "string" ? JSON.parse(val) : val,
+    LoadedConfig.rawSchema
+  )
+}).describe("RequestArgs").passthrough();
+var internalSchema = import_SanitizedArgs.rawSchema.extend({
+  taqRun: taqRunSchema,
+  config: import_zod.z.preprocess(
+    (val) => typeof val === "string" ? JSON.parse(val) : val,
+    LoadedConfig.schemas.schema
+  )
+}).describe("RequestArgs").passthrough();
+var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
+  rawSchema: rawSchema2,
+  internalSchema,
+  parseErrMsg: "The request is invalid",
+  unknownErrMsg: "Something went wrong trying to parse the request"
+});
+var schemas2 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+var rawProxyTaskSchema = rawSchema2.extend({
+  task: import_zod.z.string().min(1)
+}).describe("ProxyRequestArgs").passthrough();
+var internalProxyTaskSchema = internalSchema.extend({
+  task: import_zod.z.string().min(1)
+}).describe("ProxyRequestArgs").passthrough();
+var rawProxyTemplateSchema = rawSchema2.extend({
+  template: import_zod.z.string().min(1)
+});
+var internalProxyTemplateSchema = rawSchema2.extend({
+  template: import_zod.z.string().min(1)
+});
+var proxy = (0, import_Base.default)({
+  rawSchema: rawProxyTaskSchema,
+  internalSchema: internalProxyTaskSchema,
+  parseErrMsg: "The request is invalid",
+  unknownErrMsg: "Something went wrong trying to parse the request"
+});
+var proxyTemplate = (0, import_Base.default)({
+  rawSchema: rawProxyTemplateSchema,
+  internalSchema: internalProxyTemplateSchema,
+  parseErrMsg: "The request is invalid",
+  unknownErrMsg: "Something went wrong trying to parse the request"
+});
+var proxySchemas = proxy.schemas;
+var proxyFactory = proxy.factory;
+var createProxyRequestArgs = proxyFactory.from;
+var makeProxyRequestArgs = proxyFactory.make;
+var ofProxyRequestArgs = proxyFactory.of;
+var createProxyTemplateRequestArgs = proxyTemplate.factory.from;
+var makeProxyTemplateRequestArgs = proxyTemplate.factory.make;
+var ofProxyTemplateRequestArgs = proxyTemplate.factory.of;
+var { create, make, of, from } = factory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  createProxyRequestArgs,
+  createProxyTemplateRequestArgs,
+  factory,
+  from,
+  generatedSchemas,
+  make,
+  makeProxyRequestArgs,
+  makeProxyTemplateRequestArgs,
+  of,
+  ofProxyRequestArgs,
+  ofProxyTemplateRequestArgs,
+  proxy,
+  proxyFactory,
+  proxySchemas,
+  proxyTemplate,
+  schemas
+});
+//# sourceMappingURL=RequestArgs.js.map

package/RequestArgs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["RequestArgs.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as LoadedConfig from '@taqueria/protocol/LoadedConfig';\nimport { rawSchema as sanitizedArgsSchema } from '@taqueria/protocol/SanitizedArgs';\nimport { z } from 'zod';\n\nconst taqRunSchema = z.union([\n\tz.literal('pluginInfo'),\n\tz.literal('proxy'),\n\tz.literal('checkRuntimeDependencies'),\n\tz.literal('installRuntimeDependencies'),\n\tz.literal('proxyTemplate'),\n]);\n\nconst rawSchema = sanitizedArgsSchema.extend({\n\ttaqRun: taqRunSchema,\n\tconfig: z.preprocess(\n\t\tval => typeof val === 'string' ? JSON.parse(val) : val,\n\t\tLoadedConfig.rawSchema,\n\t),\n}).describe('RequestArgs').passthrough();\n\nconst internalSchema = sanitizedArgsSchema.extend({\n\ttaqRun: taqRunSchema,\n\tconfig: z.preprocess(\n\t\tval => typeof val === 'string' ? JSON.parse(val) : val,\n\t\tLoadedConfig.schemas.schema,\n\t),\n}).describe('RequestArgs').passthrough();\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: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport type RequestArgs = z.infer<typeof generatedSchemas.schema>;\nexport type t = RequestArgs;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as RequestArgs),\n};\n\nconst rawProxyTaskSchema = rawSchema.extend({\n\ttask: z.string().min(1),\n}).describe('ProxyRequestArgs').passthrough();\n\nconst internalProxyTaskSchema = internalSchema.extend({\n\ttask: z.string().min(1),\n}).describe('ProxyRequestArgs').passthrough();\n\nconst rawProxyTemplateSchema = rawSchema.extend({\n\ttemplate: z.string().min(1),\n});\n\nconst internalProxyTemplateSchema = rawSchema.extend({\n\ttemplate: z.string().min(1),\n});\n\ntype RawProxyInput = z.infer<typeof rawProxyTaskSchema>;\ntype ProxyInput = z.infer<typeof internalProxyTaskSchema>;\ntype RawProxyTemplateInput = z.infer<typeof rawProxyTemplateSchema>;\ntype ProxyTemplateInput = z.infer<typeof internalProxyTemplateSchema>;\n\nexport const proxy = createType<RawProxyInput, ProxyInput>({\n\trawSchema: rawProxyTaskSchema,\n\tinternalSchema: internalProxyTaskSchema,\n\tparseErrMsg: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport const proxyTemplate = createType<RawProxyTemplateInput, ProxyTemplateInput>({\n\trawSchema: rawProxyTemplateSchema,\n\tinternalSchema: internalProxyTemplateSchema,\n\tparseErrMsg: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport const proxySchemas = proxy.schemas;\nexport const proxyFactory = proxy.factory;\n\nexport type ProxyRequestArgs = z.infer<typeof proxySchemas.schema>;\nexport type ProxyTemplateRequestArgs = z.infer<typeof proxyTemplate.schemas.schema>;\n\nexport const createProxyRequestArgs = proxyFactory.from;\nexport const makeProxyRequestArgs = proxyFactory.make;\nexport const ofProxyRequestArgs = proxyFactory.of;\n\nexport const createProxyTemplateRequestArgs = proxyTemplate.factory.from;\nexport const makeProxyTemplateRequestArgs = proxyTemplate.factory.make;\nexport const ofProxyTemplateRequestArgs = proxyTemplate.factory.of;\n\nexport const { create, make, of, from } = factory;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAAA;AAAA;AAAA;AAAA,kBAAuB;AACvB,mBAA8B;AAC9B,2BAAiD;AACjD,iBAAkB;AAElB,IAAM,eAAe,aAAE,MAAM;AAAA,EAC5B,aAAE,QAAQ,YAAY;AAAA,EACtB,aAAE,QAAQ,OAAO;AAAA,EACjB,aAAE,QAAQ,0BAA0B;AAAA,EACpC,aAAE,QAAQ,4BAA4B;AAAA,EACtC,aAAE,QAAQ,eAAe;AAC1B,CAAC;AAED,IAAMC,aAAY,qBAAAC,UAAoB,OAAO;AAAA,EAC5C,QAAQ;AAAA,EACR,QAAQ,aAAE;AAAA,IACT,SAAO,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAI;AAAA,IACtC;AAAA,EACd;AACD,CAAC,EAAE,SAAS,aAAa,EAAE,YAAY;AAEvC,IAAM,iBAAiB,qBAAAA,UAAoB,OAAO;AAAA,EACjD,QAAQ;AAAA,EACR,QAAQ,aAAE;AAAA,IACT,SAAO,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAI;AAAA,IACtC,qBAAQ;AAAA,EACtB;AACD,CAAC,EAAE,SAAS,aAAa,EAAE,YAAY;AAKhC,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAC,SAA4B;AAAA,EACjF,WAAAF;AAAA,EACA;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAKM,IAAMD,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAkB;AACpE;AAEA,IAAM,qBAAqBC,WAAU,OAAO;AAAA,EAC3C,MAAM,aAAE,OAAO,EAAE,IAAI,CAAC;AACvB,CAAC,EAAE,SAAS,kBAAkB,EAAE,YAAY;AAE5C,IAAM,0BAA0B,eAAe,OAAO;AAAA,EACrD,MAAM,aAAE,OAAO,EAAE,IAAI,CAAC;AACvB,CAAC,EAAE,SAAS,kBAAkB,EAAE,YAAY;AAE5C,IAAM,yBAAyBA,WAAU,OAAO;AAAA,EAC/C,UAAU,aAAE,OAAO,EAAE,IAAI,CAAC;AAC3B,CAAC;AAED,IAAM,8BAA8BA,WAAU,OAAO;AAAA,EACpD,UAAU,aAAE,OAAO,EAAE,IAAI,CAAC;AAC3B,CAAC;AAOM,IAAM,YAAQ,YAAAE,SAAsC;AAAA,EAC1D,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAEM,IAAM,oBAAgB,YAAAA,SAAsD;AAAA,EAClF,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAEM,IAAM,eAAe,MAAM;AAC3B,IAAM,eAAe,MAAM;AAK3B,IAAM,yBAAyB,aAAa;AAC5C,IAAM,uBAAuB,aAAa;AAC1C,IAAM,qBAAqB,aAAa;AAExC,IAAM,iCAAiC,cAAc,QAAQ;AAC7D,IAAM,+BAA+B,cAAc,QAAQ;AAC3D,IAAM,6BAA6B,cAAc,QAAQ;AAEzD,IAAM,EAAE,QAAQ,MAAM,IAAI,KAAK,IAAI;","names":["schemas","rawSchema","sanitizedArgsSchema","createType"]}

package/RequestArgs.mjs

@@ -0,0 +1,89 @@
+// RequestArgs.ts
+import createType from "@taqueria/protocol/Base";
+import * as LoadedConfig from "@taqueria/protocol/LoadedConfig";
+import { rawSchema as sanitizedArgsSchema } from "@taqueria/protocol/SanitizedArgs";
+import { z } from "zod";
+var taqRunSchema = z.union([
+  z.literal("pluginInfo"),
+  z.literal("proxy"),
+  z.literal("checkRuntimeDependencies"),
+  z.literal("installRuntimeDependencies"),
+  z.literal("proxyTemplate")
+]);
+var rawSchema2 = sanitizedArgsSchema.extend({
+  taqRun: taqRunSchema,
+  config: z.preprocess(
+    (val) => typeof val === "string" ? JSON.parse(val) : val,
+    LoadedConfig.rawSchema
+  )
+}).describe("RequestArgs").passthrough();
+var internalSchema = sanitizedArgsSchema.extend({
+  taqRun: taqRunSchema,
+  config: z.preprocess(
+    (val) => typeof val === "string" ? JSON.parse(val) : val,
+    LoadedConfig.schemas.schema
+  )
+}).describe("RequestArgs").passthrough();
+var { schemas: generatedSchemas, factory } = createType({
+  rawSchema: rawSchema2,
+  internalSchema,
+  parseErrMsg: "The request is invalid",
+  unknownErrMsg: "Something went wrong trying to parse the request"
+});
+var schemas2 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+var rawProxyTaskSchema = rawSchema2.extend({
+  task: z.string().min(1)
+}).describe("ProxyRequestArgs").passthrough();
+var internalProxyTaskSchema = internalSchema.extend({
+  task: z.string().min(1)
+}).describe("ProxyRequestArgs").passthrough();
+var rawProxyTemplateSchema = rawSchema2.extend({
+  template: z.string().min(1)
+});
+var internalProxyTemplateSchema = rawSchema2.extend({
+  template: z.string().min(1)
+});
+var proxy = createType({
+  rawSchema: rawProxyTaskSchema,
+  internalSchema: internalProxyTaskSchema,
+  parseErrMsg: "The request is invalid",
+  unknownErrMsg: "Something went wrong trying to parse the request"
+});
+var proxyTemplate = createType({
+  rawSchema: rawProxyTemplateSchema,
+  internalSchema: internalProxyTemplateSchema,
+  parseErrMsg: "The request is invalid",
+  unknownErrMsg: "Something went wrong trying to parse the request"
+});
+var proxySchemas = proxy.schemas;
+var proxyFactory = proxy.factory;
+var createProxyRequestArgs = proxyFactory.from;
+var makeProxyRequestArgs = proxyFactory.make;
+var ofProxyRequestArgs = proxyFactory.of;
+var createProxyTemplateRequestArgs = proxyTemplate.factory.from;
+var makeProxyTemplateRequestArgs = proxyTemplate.factory.make;
+var ofProxyTemplateRequestArgs = proxyTemplate.factory.of;
+var { create, make, of, from } = factory;
+export {
+  create,
+  createProxyRequestArgs,
+  createProxyTemplateRequestArgs,
+  factory,
+  from,
+  generatedSchemas,
+  make,
+  makeProxyRequestArgs,
+  makeProxyTemplateRequestArgs,
+  of,
+  ofProxyRequestArgs,
+  ofProxyTemplateRequestArgs,
+  proxy,
+  proxyFactory,
+  proxySchemas,
+  proxyTemplate,
+  schemas2 as schemas
+};
+//# sourceMappingURL=RequestArgs.mjs.map

package/RequestArgs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["RequestArgs.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as LoadedConfig from '@taqueria/protocol/LoadedConfig';\nimport { rawSchema as sanitizedArgsSchema } from '@taqueria/protocol/SanitizedArgs';\nimport { z } from 'zod';\n\nconst taqRunSchema = z.union([\n\tz.literal('pluginInfo'),\n\tz.literal('proxy'),\n\tz.literal('checkRuntimeDependencies'),\n\tz.literal('installRuntimeDependencies'),\n\tz.literal('proxyTemplate'),\n]);\n\nconst rawSchema = sanitizedArgsSchema.extend({\n\ttaqRun: taqRunSchema,\n\tconfig: z.preprocess(\n\t\tval => typeof val === 'string' ? JSON.parse(val) : val,\n\t\tLoadedConfig.rawSchema,\n\t),\n}).describe('RequestArgs').passthrough();\n\nconst internalSchema = sanitizedArgsSchema.extend({\n\ttaqRun: taqRunSchema,\n\tconfig: z.preprocess(\n\t\tval => typeof val === 'string' ? JSON.parse(val) : val,\n\t\tLoadedConfig.schemas.schema,\n\t),\n}).describe('RequestArgs').passthrough();\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: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport type RequestArgs = z.infer<typeof generatedSchemas.schema>;\nexport type t = RequestArgs;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as RequestArgs),\n};\n\nconst rawProxyTaskSchema = rawSchema.extend({\n\ttask: z.string().min(1),\n}).describe('ProxyRequestArgs').passthrough();\n\nconst internalProxyTaskSchema = internalSchema.extend({\n\ttask: z.string().min(1),\n}).describe('ProxyRequestArgs').passthrough();\n\nconst rawProxyTemplateSchema = rawSchema.extend({\n\ttemplate: z.string().min(1),\n});\n\nconst internalProxyTemplateSchema = rawSchema.extend({\n\ttemplate: z.string().min(1),\n});\n\ntype RawProxyInput = z.infer<typeof rawProxyTaskSchema>;\ntype ProxyInput = z.infer<typeof internalProxyTaskSchema>;\ntype RawProxyTemplateInput = z.infer<typeof rawProxyTemplateSchema>;\ntype ProxyTemplateInput = z.infer<typeof internalProxyTemplateSchema>;\n\nexport const proxy = createType<RawProxyInput, ProxyInput>({\n\trawSchema: rawProxyTaskSchema,\n\tinternalSchema: internalProxyTaskSchema,\n\tparseErrMsg: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport const proxyTemplate = createType<RawProxyTemplateInput, ProxyTemplateInput>({\n\trawSchema: rawProxyTemplateSchema,\n\tinternalSchema: internalProxyTemplateSchema,\n\tparseErrMsg: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport const proxySchemas = proxy.schemas;\nexport const proxyFactory = proxy.factory;\n\nexport type ProxyRequestArgs = z.infer<typeof proxySchemas.schema>;\nexport type ProxyTemplateRequestArgs = z.infer<typeof proxyTemplate.schemas.schema>;\n\nexport const createProxyRequestArgs = proxyFactory.from;\nexport const makeProxyRequestArgs = proxyFactory.make;\nexport const ofProxyRequestArgs = proxyFactory.of;\n\nexport const createProxyTemplateRequestArgs = proxyTemplate.factory.from;\nexport const makeProxyTemplateRequestArgs = proxyTemplate.factory.make;\nexport const ofProxyTemplateRequestArgs = proxyTemplate.factory.of;\n\nexport const { create, make, of, from } = factory;\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,YAAY,kBAAkB;AAC9B,SAAS,aAAa,2BAA2B;AACjD,SAAS,SAAS;AAElB,IAAM,eAAe,EAAE,MAAM;AAAA,EAC5B,EAAE,QAAQ,YAAY;AAAA,EACtB,EAAE,QAAQ,OAAO;AAAA,EACjB,EAAE,QAAQ,0BAA0B;AAAA,EACpC,EAAE,QAAQ,4BAA4B;AAAA,EACtC,EAAE,QAAQ,eAAe;AAC1B,CAAC;AAED,IAAMA,aAAY,oBAAoB,OAAO;AAAA,EAC5C,QAAQ;AAAA,EACR,QAAQ,EAAE;AAAA,IACT,SAAO,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAI;AAAA,IACtC;AAAA,EACd;AACD,CAAC,EAAE,SAAS,aAAa,EAAE,YAAY;AAEvC,IAAM,iBAAiB,oBAAoB,OAAO;AAAA,EACjD,QAAQ;AAAA,EACR,QAAQ,EAAE;AAAA,IACT,SAAO,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAI;AAAA,IACtC,qBAAQ;AAAA,EACtB;AACD,CAAC,EAAE,SAAS,aAAa,EAAE,YAAY;AAKhC,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA4B;AAAA,EACjF,WAAAA;AAAA,EACA;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAKM,IAAMC,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAkB;AACpE;AAEA,IAAM,qBAAqBD,WAAU,OAAO;AAAA,EAC3C,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AACvB,CAAC,EAAE,SAAS,kBAAkB,EAAE,YAAY;AAE5C,IAAM,0BAA0B,eAAe,OAAO;AAAA,EACrD,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AACvB,CAAC,EAAE,SAAS,kBAAkB,EAAE,YAAY;AAE5C,IAAM,yBAAyBA,WAAU,OAAO;AAAA,EAC/C,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC;AAC3B,CAAC;AAED,IAAM,8BAA8BA,WAAU,OAAO;AAAA,EACpD,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC;AAC3B,CAAC;AAOM,IAAM,QAAQ,WAAsC;AAAA,EAC1D,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAEM,IAAM,gBAAgB,WAAsD;AAAA,EAClF,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAEM,IAAM,eAAe,MAAM;AAC3B,IAAM,eAAe,MAAM;AAK3B,IAAM,yBAAyB,aAAa;AAC5C,IAAM,uBAAuB,aAAa;AAC1C,IAAM,qBAAqB,aAAa;AAExC,IAAM,iCAAiC,cAAc,QAAQ;AAC7D,IAAM,+BAA+B,cAAc,QAAQ;AAC3D,IAAM,6BAA6B,cAAc,QAAQ;AAEzD,IAAM,EAAE,QAAQ,MAAM,IAAI,KAAK,IAAI;","names":["rawSchema","schemas"]}

package/SHA256.d.ts

@@ -0,0 +1,29 @@
+import { TaqError } from '@taqueria/protocol/TaqError';
+import { FutureInstance as Future } from 'fluture';
+import { z } from 'zod';
+export declare const rawSchema: z.ZodString;
+export declare const toSHA256: (value: string) => Promise<string & {
+    readonly __kind: any;
+}>;
+export declare const internalSchema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
+    readonly __kind: any;
+}, any>;
+export declare type SHA256 = z.infer<typeof internalSchema>;
+export declare type t = SHA256;
+export declare const create: (input: string) => string & {
+    readonly __kind: any;
+}, of: (input: unknown) => Future<TaqError, string & {
+    readonly __kind: any;
+}>, make: (input: string) => Future<TaqError, string & {
+    readonly __kind: any;
+}>;
+export declare const schemas: {
+    schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
+        readonly __kind: any;
+    }, any>, string & {
+        readonly __kind: any;
+    }, any>;
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+};
+//# sourceMappingURL=SHA256.d.ts.map

package/SHA256.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SHA256.d.ts","sourceRoot":"","sources":["SHA256.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,cAAc,IAAI,MAAM,EAAmB,MAAM,SAAS,CAAC;AAEpE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,SAAS,aAAiD,CAAC;AAWxE,eAAO,MAAM,QAAQ,UAAiB,MAAM;;EAQ3C,CAAC;AAEF,eAAO,MAAM,cAAc;;OAA0B,CAAC;AAEtD,oBAAY,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACpD,oBAAY,CAAC,GAAG,MAAM,CAAC;AACvB,eAAO,MAAQ,MAAM;;GAAE,EAAE;;IAAE,IAAI;;EAAY,CAAC;AAC5C,eAAO,MAAM,OAAO;;;;;;;;CAGnB,CAAC"}

package/SHA256.js

@@ -0,0 +1,79 @@
+"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);
+
+// SHA256.ts
+var SHA256_exports = {};
+__export(SHA256_exports, {
+  create: () => create,
+  internalSchema: () => internalSchema,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas,
+  toSHA256: () => toSHA256
+});
+module.exports = __toCommonJS(SHA256_exports);
+var import_webcrypto = require("@peculiar/webcrypto");
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var import_TaqError = require("@taqueria/protocol/TaqError");
+var import_fluture = require("fluture");
+var import_util = require("util");
+var import_zod = require("zod");
+var eager = (f) => (0, import_fluture.promise)(
+  (0, import_fluture.mapRej)((err) => new import_TaqError.E_TaqError(err))(f)
+);
+var rawSchema = import_zod.z.string({ description: "SHA256" }).length(64);
+var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
+  isStringLike: true,
+  rawSchema,
+  parseErrMsg: (value) => `${value} is an invalid SHA256 hash`,
+  unknownErrMsg: (value) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`
+});
+var toSHA256 = async (value) => {
+  const encoder = new import_util.TextEncoder();
+  const data = encoder.encode(value);
+  const crypto = new import_webcrypto.Crypto();
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hash));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return eager(factory.make(hashHex));
+};
+var internalSchema = generatedSchemas.schema;
+var { create, of, make } = factory;
+var schemas = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  internalSchema,
+  make,
+  of,
+  rawSchema,
+  schemas,
+  toSHA256
+});
+//# sourceMappingURL=SHA256.js.map

package/SHA256.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["SHA256.ts"],"sourcesContent":["import { Crypto } from '@peculiar/webcrypto';\nimport createType from '@taqueria/protocol/Base';\nimport { E_TaqError, TaqError } from '@taqueria/protocol/TaqError';\nimport { FutureInstance as Future, mapRej, promise } from 'fluture';\nimport { TextEncoder } from 'util';\nimport { z } from 'zod';\n\nconst eager = <T>(f: Future<TaqError, T>) =>\n\tpromise(\n\t\tmapRej((err: TaqError) => new E_TaqError(err))(f),\n\t);\n\nexport const rawSchema = z.string({ description: 'SHA256' }).length(64);\n\ntype RawInput = z.infer<typeof rawSchema>;\n\nconst { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({\n\tisStringLike: true,\n\trawSchema,\n\tparseErrMsg: (value: unknown) => `${value} is an invalid SHA256 hash`,\n\tunknownErrMsg: (value: unknown) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`,\n});\n\nexport const toSHA256 = async (value: string) => {\n\tconst encoder = new TextEncoder();\n\tconst data = encoder.encode(value);\n\tconst crypto = new Crypto();\n\tconst hash = await crypto.subtle.digest('SHA-256', data);\n\tconst hashArray = Array.from(new Uint8Array(hash)); // convert buffer to byte array\n\tconst hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');\n\treturn eager(factory.make(hashHex));\n};\n\nexport const internalSchema = generatedSchemas.schema;\n\nexport type SHA256 = z.infer<typeof internalSchema>;\nexport type t = SHA256;\nexport const { create, of, make } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as SHA256),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAuB;AACvB,kBAAuB;AACvB,sBAAqC;AACrC,qBAA0D;AAC1D,kBAA4B;AAC5B,iBAAkB;AAElB,IAAM,QAAQ,CAAI,UACjB;AAAA,MACC,uBAAO,CAAC,QAAkB,IAAI,2BAAW,GAAG,CAAC,EAAE,CAAC;AACjD;AAEM,IAAM,YAAY,aAAE,OAAO,EAAE,aAAa,SAAS,CAAC,EAAE,OAAO,EAAE;AAItE,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAA,SAA+B;AAAA,EAC7E,cAAc;AAAA,EACd;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe,CAAC,UAAmB,yEAAyE;AAC7G,CAAC;AAEM,IAAM,WAAW,OAAO,UAAkB;AAChD,QAAM,UAAU,IAAI,wBAAY;AAChC,QAAM,OAAO,QAAQ,OAAO,KAAK;AACjC,QAAM,SAAS,IAAI,wBAAO;AAC1B,QAAM,OAAO,MAAM,OAAO,OAAO,OAAO,WAAW,IAAI;AACvD,QAAM,YAAY,MAAM,KAAK,IAAI,WAAW,IAAI,CAAC;AACjD,QAAM,UAAU,UAAU,IAAI,OAAK,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAC3E,SAAO,MAAM,QAAQ,KAAK,OAAO,CAAC;AACnC;AAEO,IAAM,iBAAiB,iBAAiB;AAIxC,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAC7B,IAAM,UAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAa;AAC/D;","names":["createType"]}

package/SHA256.mjs

@@ -0,0 +1,42 @@
+// SHA256.ts
+import { Crypto } from "@peculiar/webcrypto";
+import createType from "@taqueria/protocol/Base";
+import { E_TaqError } from "@taqueria/protocol/TaqError";
+import { mapRej, promise } from "fluture";
+import { TextEncoder } from "util";
+import { z } from "zod";
+var eager = (f) => promise(
+  mapRej((err) => new E_TaqError(err))(f)
+);
+var rawSchema = z.string({ description: "SHA256" }).length(64);
+var { schemas: generatedSchemas, factory } = createType({
+  isStringLike: true,
+  rawSchema,
+  parseErrMsg: (value) => `${value} is an invalid SHA256 hash`,
+  unknownErrMsg: (value) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`
+});
+var toSHA256 = async (value) => {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const crypto = new Crypto();
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hash));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return eager(factory.make(hashHex));
+};
+var internalSchema = generatedSchemas.schema;
+var { create, of, make } = factory;
+var schemas = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+export {
+  create,
+  internalSchema,
+  make,
+  of,
+  rawSchema,
+  schemas,
+  toSHA256
+};
+//# sourceMappingURL=SHA256.mjs.map

package/SHA256.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["SHA256.ts"],"sourcesContent":["import { Crypto } from '@peculiar/webcrypto';\nimport createType from '@taqueria/protocol/Base';\nimport { E_TaqError, TaqError } from '@taqueria/protocol/TaqError';\nimport { FutureInstance as Future, mapRej, promise } from 'fluture';\nimport { TextEncoder } from 'util';\nimport { z } from 'zod';\n\nconst eager = <T>(f: Future<TaqError, T>) =>\n\tpromise(\n\t\tmapRej((err: TaqError) => new E_TaqError(err))(f),\n\t);\n\nexport const rawSchema = z.string({ description: 'SHA256' }).length(64);\n\ntype RawInput = z.infer<typeof rawSchema>;\n\nconst { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({\n\tisStringLike: true,\n\trawSchema,\n\tparseErrMsg: (value: unknown) => `${value} is an invalid SHA256 hash`,\n\tunknownErrMsg: (value: unknown) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`,\n});\n\nexport const toSHA256 = async (value: string) => {\n\tconst encoder = new TextEncoder();\n\tconst data = encoder.encode(value);\n\tconst crypto = new Crypto();\n\tconst hash = await crypto.subtle.digest('SHA-256', data);\n\tconst hashArray = Array.from(new Uint8Array(hash)); // convert buffer to byte array\n\tconst hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');\n\treturn eager(factory.make(hashHex));\n};\n\nexport const internalSchema = generatedSchemas.schema;\n\nexport type SHA256 = z.infer<typeof internalSchema>;\nexport type t = SHA256;\nexport const { create, of, make } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as SHA256),\n};\n"],"mappings":";AAAA,SAAS,cAAc;AACvB,OAAO,gBAAgB;AACvB,SAAS,kBAA4B;AACrC,SAAmC,QAAQ,eAAe;AAC1D,SAAS,mBAAmB;AAC5B,SAAS,SAAS;AAElB,IAAM,QAAQ,CAAI,MACjB;AAAA,EACC,OAAO,CAAC,QAAkB,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;AACjD;AAEM,IAAM,YAAY,EAAE,OAAO,EAAE,aAAa,SAAS,CAAC,EAAE,OAAO,EAAE;AAItE,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA+B;AAAA,EAC7E,cAAc;AAAA,EACd;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe,CAAC,UAAmB,yEAAyE;AAC7G,CAAC;AAEM,IAAM,WAAW,OAAO,UAAkB;AAChD,QAAM,UAAU,IAAI,YAAY;AAChC,QAAM,OAAO,QAAQ,OAAO,KAAK;AACjC,QAAM,SAAS,IAAI,OAAO;AAC1B,QAAM,OAAO,MAAM,OAAO,OAAO,OAAO,WAAW,IAAI;AACvD,QAAM,YAAY,MAAM,KAAK,IAAI,WAAW,IAAI,CAAC;AACjD,QAAM,UAAU,UAAU,IAAI,OAAK,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAC3E,SAAO,MAAM,QAAQ,KAAK,OAAO,CAAC;AACnC;AAEO,IAAM,iBAAiB,iBAAiB;AAIxC,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAC7B,IAAM,UAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAa;AAC/D;","names":[]}

package/SandboxAccountConfig.d.ts

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+export declare const rawSchema: z.ZodObject<{
+    encryptedKey: z.ZodString;
+    publicKeyHash: z.ZodString;
+    secretKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    encryptedKey: string;
+    publicKeyHash: string;
+    secretKey: string;
+}, {
+    encryptedKey: string;
+    publicKeyHash: string;
+    secretKey: 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>, {
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    }, any>;
+}, factory: {
+    make: (input: {
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    }>;
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    }>;
+    create: (input: {
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } | {
+        encryptedKey: string;
+        publicKeyHash: string;
+        secretKey: string;
+    }) => {
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    };
+    from: (input: unknown) => {
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    };
+};
+export declare type SandboxAccountConfig = z.infer<typeof generatedSchemas.schema>;
+export declare type t = SandboxAccountConfig;
+export declare const create: (input: {
+    encryptedKey: string;
+    publicKeyHash: string & {
+        readonly __kind: any;
+    };
+    secretKey: string;
+} | {
+    encryptedKey: string;
+    publicKeyHash: string;
+    secretKey: string;
+}) => {
+    encryptedKey: string;
+    publicKeyHash: string & {
+        readonly __kind: any;
+    };
+    secretKey: string;
+} & {
+    readonly __kind: any;
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    encryptedKey: string;
+    publicKeyHash: string & {
+        readonly __kind: any;
+    };
+    secretKey: string;
+} & {
+    readonly __kind: any;
+}>, make: (input: {
+    encryptedKey: string;
+    publicKeyHash: string & {
+        readonly __kind: any;
+    };
+    secretKey: string;
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    encryptedKey: string;
+    publicKeyHash: string & {
+        readonly __kind: any;
+    };
+    secretKey: string;
+} & {
+    readonly __kind: any;
+}>;
+export declare const schemas: {
+    schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    }, any>, {
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    }, any>;
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+};
+//# sourceMappingURL=SandboxAccountConfig.d.ts.map

package/SandboxAccountConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxAccountConfig.d.ts","sourceRoot":"","sources":["SandboxAccountConfig.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,SAAS;;;;;;;;;;;;EAI8B,CAAC;AAMrD,eAAO,MAAiB,gBAAgB;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK/C,CAAC;AAEH,oBAAY,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAC3E,oBAAY,CAAC,GAAG,oBAAoB,CAAC;AACrC,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;GAAE,EAAE;;;;;;;;IAAE,IAAI;;;;;;;;;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC"}

package/SandboxAccountConfig.js

@@ -0,0 +1,72 @@
+"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);
+
+// SandboxAccountConfig.ts
+var SandboxAccountConfig_exports = {};
+__export(SandboxAccountConfig_exports, {
+  create: () => create,
+  factory: () => factory,
+  generatedSchemas: () => generatedSchemas,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas2
+});
+module.exports = __toCommonJS(SandboxAccountConfig_exports);
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var PublicKeyHash = __toESM(require("@taqueria/protocol/PublicKeyHash"));
+var import_zod = require("zod");
+var internalSchema = import_zod.z.object({
+  encryptedKey: import_zod.z.string({ description: "Sandbox Account Encrypted Key" }).min(1),
+  publicKeyHash: PublicKeyHash.schemas.schema.describe("Sandbox Account Public Key Hash"),
+  secretKey: import_zod.z.string({ description: "Sandbox Account Secret Key" }).min(1)
+}, { description: "Sandbox Account Configuration" });
+var rawSchema = import_zod.z.object({
+  encryptedKey: import_zod.z.string({ description: "Sandbox Account Encrypted Key" }).min(1),
+  publicKeyHash: import_zod.z.string({ description: "Sandbox Account Public Key Hash" }).min(1),
+  secretKey: import_zod.z.string({ description: "Sandbox Account Secret Key" }).min(1)
+}, { description: "Sandbox Account Configuration" });
+var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
+  rawSchema,
+  internalSchema,
+  parseErrMsg: "The sandbox account configuration is invalid",
+  unknownErrMsg: "Something went wrong trying to parse the sandbox account configuration"
+});
+var { create, of, make } = 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=SandboxAccountConfig.js.map